// Copyright(c) 2017-2018, Intel Corporation
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of Intel Corporation nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
#include <Python.h>
#include <opae/cxx/core/token.h>
#include <opae/cxx/core/version.h>
#include <opae/fpga.h>
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <atomic>
#include <exception>
#include "pyerrors.h"
#include "pyevents.h"
#include "pyhandle.h"
#include "pyproperties.h"
#include "pyshared_buffer.h"
#include "pysysobject.h"
#include "pytoken.h"
namespace py = pybind11;
using opae::fpga::types::properties;
using opae::fpga::types::token;
using opae::fpga::types::handle;
using opae::fpga::types::shared_buffer;
using opae::fpga::types::event;
using opae::fpga::types::error;
using opae::fpga::types::sysobject;
using opae::fpga::types::version;
const char *memory_barrier_doc = R"opaedoc(
Place a memory barrier or fence to ensure that all preceding memory operations have completed before continuing.
)opaedoc";
#ifdef OPAE_EMBEDDED
#include <pybind11/embed.h>
PYBIND11_EMBEDDED_MODULE(_opae, m) {
m.def("initialize", &fpgaInitialize);
#else
PYBIND11_MODULE(_opae, m) {
fpgaInitialize(nullptr);
#endif
py::options opts;
// opts.disable_function_signatures();
m.doc() = "Open Programmable Acceleration Engine - Python bindings";
// define enumerations
py::enum_<fpga_result>(m, "fpga_result", py::arithmetic(),
"OPAE return codes")
.value("OK", FPGA_OK)
.value("INVALID_PARAM", FPGA_INVALID_PARAM)
.value("BUSY", FPGA_BUSY)
.value("EXCEPTION", FPGA_EXCEPTION)
.value("NOT_FOUND", FPGA_NOT_FOUND)
.value("NO_MEMORY", FPGA_NO_MEMORY)
.value("NOT_SUPPORTED", FPGA_NOT_SUPPORTED)
.value("NO_DRIVER", FPGA_NO_DRIVER)
.value("NO_DAEMON", FPGA_NO_DAEMON)
.value("NO_ACCESS", FPGA_NO_ACCESS)
.value("RECONF_ERROR", FPGA_RECONF_ERROR)
.export_values();
py::enum_<fpga_objtype>(m, "fpga_objtype", py::arithmetic(),
"OPAE resource objects")
.value("DEVICE", FPGA_DEVICE)
.value("ACCELERATOR", FPGA_ACCELERATOR)
.export_values();
py::enum_<fpga_open_flags>(m, "fpga_open_flags", py::arithmetic(),
"OPAE flags for opening resources")
.value("OPEN_SHARED", FPGA_OPEN_SHARED)
.export_values();
py::enum_<fpga_event_type>(m, "fpga_event_type", py::arithmetic(),
"OPAE event type")
.value("EVENT_INTERRUPT", FPGA_EVENT_INTERRUPT)
.value("EVENT_ERROR", FPGA_EVENT_ERROR)
.value("EVENT_POWER_THERMAL", FPGA_EVENT_POWER_THERMAL)
.export_values();
py::enum_<fpga_accelerator_state>(m, "fpga_accelerator_state",
py::arithmetic(), "OPAE accelerator_state")
.value("ACCELERATOR_ASSIGNED", FPGA_ACCELERATOR_ASSIGNED)
.value("ACCELERATOR_UNASSIGNED", FPGA_ACCELERATOR_UNASSIGNED)
.export_values();
py::enum_<fpga_sysobject_flags>(m, "fpga_sysobject_flags", py::arithmetic(),
"OPAE sysobject API flags.")
.value("SYSOBJECT_SYNC", FPGA_OBJECT_SYNC)
.value("SYSOBJECT_RAW", FPGA_OBJECT_RAW)
.value("SYSOBJECT_GLOB", FPGA_OBJECT_GLOB)
.value("SYSOBJECT_RECURSE_ONE", FPGA_OBJECT_RECURSE_ONE)
.value("SYSOBJECT_RECURSE_ALL", FPGA_OBJECT_RECURSE_ALL)
.export_values();
py::enum_<fpga_reconf_flags>(
m, "fpga_reconf_flags", py::arithmetic(),
"Flags that define how an accelerator is opened.")
.value("RECONF_FORCE", FPGA_RECONF_FORCE)
.export_values();
// version method
m.def("version", &version::as_string,
"Get the OPAE runtime version as a string");
m.def("build", &version::build, "Get the OPAE runtime build hash");
// define properties class
py::class_<properties, properties::ptr_t> pyproperties(m, "properties",
properties_doc());
pyproperties.def(py::init(&properties_get), properties_doc_get())
.def(py::init(&properties_get_token), properties_doc_get_token())
.def(py::init(&properties_get_handle), properties_doc_get_handle())
.def_property("parent", properties_get_parent, properties_set_parent,
properties_doc_parent())
.def_property("guid", properties_get_guid, properties_set_guid,
properties_doc_guid())
.def_property("type", properties_get_type, properties_set_type,
properties_doc_type())
.def_property("segment", properties_get_segment, properties_set_segment,
properties_doc_segment())
.def_property("bus", properties_get_bus, properties_set_bus,
properties_doc_bus())
.def_property("device", properties_get_device, properties_set_device,
properties_doc_device())
.def_property("function", properties_get_function,
properties_set_function, properties_doc_function())
.def_property("socket_id", properties_get_socket_id,
properties_set_socket_id, properties_doc_socket_id())
.def_property("object_id", properties_get_object_id,
properties_set_object_id, properties_doc_object_id())
.def_property("num_errors", properties_get_num_errors,
properties_set_num_errors, properties_doc_num_errors())
.def_property("num_slots", properties_get_num_slots,
properties_set_num_slots, properties_doc_num_slots())
.def_property("bbs_id", properties_get_bbs_id, properties_set_bbs_id,
properties_doc_bbs_id())
.def_property("bbs_version", properties_get_bbs_version,
properties_set_bbs_version, properties_doc_bbs_version())
.def_property("vendor_id", properties_get_vendor_id,
properties_set_vendor_id, properties_doc_vendor_id())
.def_property("device_id", properties_get_device_id,
properties_set_device_id, properties_doc_device_id())
.def_property("model", properties_get_model, properties_set_model,
properties_doc_model())
.def_property("local_memory_size", properties_get_local_memory_size,
properties_set_local_memory_size,
properties_doc_local_memory_size())
.def_property("capabilities", properties_get_capabilities,
properties_set_capabilities, properties_doc_capabilities())
.def_property("num_mmio", properties_get_num_mmio,
properties_set_num_mmio, properties_doc_num_mmio())
.def_property("num_interrupts", properties_get_num_interrupts,
properties_set_num_interrupts,
properties_doc_num_interrupts())
.def_property("accelerator_state", properties_get_accelerator_state,
properties_set_accelerator_state,
properties_doc_accelerator_state());
// memory fence
m.def("memory_barrier",
[]() { std::atomic_thread_fence(std::memory_order_release); },
memory_barrier_doc);
// define token class
m.def("enumerate", &token::enumerate, token_doc_enumerate())
.def("enumerate", token_enumerate_kwargs, token_doc_enumerate_kwargs());
py::class_<token, token::ptr_t> pytoken(m, "token", token_doc());
pytoken.def("__getattr__", token_get_sysobject, sysobject_doc_token_get())
.def("__getitem__", token_get_sysobject, sysobject_doc_token_get())
.def("find", token_find_sysobject, sysobject_doc_token_find(),
py::arg("name"), py::arg("flags") = 0);
// define handle class
m.def("open", handle_open, handle_doc_open(), py::arg("tok"),
py::arg("flags") = 0);
py::class_<handle, handle::ptr_t> pyhandle(m, "handle");
pyhandle.def("__enter__", handle_context_enter, handle_doc_context_enter())
.def("__exit__", handle_context_exit, handle_doc_context_exit())
.def("reconfigure", handle_reconfigure, handle_doc_reconfigure(),
py::arg("slot"), py::arg("fd"), py::arg("flags") = 0)
.def("__bool__", handle_valid, handle_doc_valid())
.def("close", &handle::close, handle_doc_close())
.def("reset", &handle::reset, handle_doc_reset())
.def("read_csr32", &handle::read_csr32, handle_doc_read_csr32(),
py::arg("offset"), py::arg("csr_space") = 0)
.def("read_csr64", &handle::read_csr64, handle_doc_read_csr64(),
py::arg("offset"), py::arg("csr_space") = 0)
.def("write_csr32", &handle::write_csr32, handle_doc_write_csr32(),
py::arg("offset"), py::arg("value"), py::arg("csr_space") = 0)
.def("write_csr64", &handle::write_csr64, handle_doc_write_csr64(),
py::arg("offset"), py::arg("value"), py::arg("csr_space") = 0)
.def("__getattr__", handle_get_sysobject, sysobject_doc_handle_get())
.def("__getitem__", handle_get_sysobject, sysobject_doc_handle_get())
.def("find", handle_find_sysobject, sysobject_doc_handle_find(),
py::arg("name"), py::arg("flags") = 0);
// define shared_buffer class
m.def("allocate_shared_buffer", shared_buffer_allocate,
shared_buffer_doc_allocate());
py::class_<shared_buffer, shared_buffer::ptr_t> pybuffer(
m, "shared_buffer", py::buffer_protocol(), shared_buffer_doc());
pybuffer.def("size", &shared_buffer::size, shared_buffer_doc_size())
.def("wsid", &shared_buffer::wsid, shared_buffer_doc_wsid())
.def("io_address", &shared_buffer::io_address,
shared_buffer_doc_io_address())
.def("fill", &shared_buffer::fill, shared_buffer_doc_fill())
.def("poll", shared_buffer_poll<uint8_t>,
"Poll for an 8-bit value being set at given offset",
py::arg("offset"), py::arg("value"), py::arg("mask") = 0,
py::arg("timeout_usec") = 1000)
.def("poll32", shared_buffer_poll<uint32_t>,
"Poll for a 32-bit value being set at given offset",
py::arg("offset"), py::arg("value"), py::arg("mask") = 0,
py::arg("timeout_usec") = 1000)
.def("poll64", shared_buffer_poll<uint64_t>,
"Poll for a 64-bit value being set at given offset",
py::arg("offset"), py::arg("value"), py::arg("mask"),
py::arg("timeout_usec") = 1000)
.def("compare", &shared_buffer::compare, shared_buffer_doc_compare())
.def("copy", shared_buffer_copy, shared_buffer_doc_copy(),
py::arg("other"), py::arg("size") = 0)
.def_buffer([](shared_buffer &b) -> py::buffer_info {
return py::buffer_info(
const_cast<uint8_t *>(b.c_type()), sizeof(uint8_t),
py::format_descriptor<uint8_t>::format(), b.size());
})
.def("read32", &shared_buffer::read<uint32_t>, shared_buffer_doc_read32())
.def("read64", &shared_buffer::read<uint64_t>, shared_buffer_doc_read64())
.def("write32", &shared_buffer::write<uint32_t>,
shared_buffer_doc_write32())
.def("write64", &shared_buffer::write<uint64_t>,
shared_buffer_doc_write64())
.def("split", shared_buffer_split, shared_buffer_doc_split())
.def("__getitem__", shared_buffer_getitem, shared_buffer_doc_getitem())
.def("__setitem__", shared_buffer_setitem, shared_buffer_doc_setitem())
.def("__getitem__", shared_buffer_getslice, shared_buffer_doc_getslice());
// define event class
m.def("register_event", event_register_event, event_doc_register_event(),
py::arg("handle"), py::arg("event_type"), py::arg("flags") = 0);
py::class_<event, event::ptr_t> pyevent(m, "event", event_doc());
pyevent.def("os_object", event_os_object, event_doc_os_object());
py::class_<error, error::ptr_t> pyerror(m, "error", error_doc());
pyerror.def_property_readonly("name", &error::name, error_doc_name())
.def_property_readonly("can_clear", &error::can_clear,
error_doc_can_clear())
.def("read_value", &error::read_value, error_doc_read_value());
m.def("errors", error_errors, error_doc_errors());
// define object class
py::class_<sysobject, sysobject::ptr_t> pysysobject(m, "sysobject",
sysobject_doc());
pysysobject
.def("__getattr__", sysobject_get_sysobject, sysobject_doc_object_get())
.def("__getitem__", sysobject_get_sysobject, sysobject_doc_object_get())
.def("find", sysobject_find_sysobject, sysobject_doc_object_find(),
py::arg("name"), py::arg("flags") = 0)
.def("read64",
[](sysobject::ptr_t obj) { return obj->read64(FPGA_OBJECT_SYNC); })
.def("write64", &sysobject::write64)
.def("size", &sysobject::size)
.def("bytes", sysobject_bytes, sysobject_doc_bytes())
.def("__getitem__", sysobject_getitem, sysobject_doc_getitem())
.def("__getitem__", sysobject_getslice, sysobject_doc_getslice());
}