Merge pull request #4 from j-marjanovic/feat/write-bulk

Add write_bulk method

Author: patrislav1

inc/udmaio/HwAccessor.hpp

@@ -69,6 +69,8 @@ class HwAccessor : public Logger, private boost::noncopyable {
         return {};
     }
 
+    virtual void write_bulk(uint32_t offs, std::vector<uint8_t> data) {}
+
     /**
      * @brief Read register from UIO interface
      *
@@ -237,6 +239,11 @@ class HwAccessorMmap : public HwAccessor {
         return result;
     }
 
+    virtual void write_bulk(uint32_t offs, std::vector<uint8_t> data) final override {
+        auto dst = _mem_ptr<uint8_t>(offs);
+        memcpy(const_cast<uint8_t*>(dst), &data[0], std::size(data));
+    }
+
   public:
     UioRegion get_phys_region() const final override {
         const size_t access_offs =

inc/udmaio/UioIf.hpp

@@ -79,6 +79,10 @@ class UioIf : private boost::noncopyable {
         return _hw->read_bulk(offs, size);
     }
 
+    void write_bulk(uint32_t offs, std::vector<uint8_t> data) {
+        return _hw->write_bulk(offs, data);
+    }
+
     template <typename C>
     C _rd_reg(uint32_t offs) const {
         return _hw->template _rd_reg<C>(offs);

pyudmaio/pyudmaio/binding.pyi

@@ -445,6 +445,8 @@ class UioIf:
         ...
     def read_bulk(self, arg0: typing.SupportsInt, arg1: typing.SupportsInt) -> numpy.typing.NDArray[numpy.uint8]:
         ...
+    def write_bulk(self, arg0: typing.SupportsInt, arg1: bytes) -> None:
+        ...
     def wait_for_interrupt(self) -> int:
         ...
 class UioMemSgdma(UioIf):

pyudmaio/src/PythonBinding.cpp

@@ -32,6 +32,7 @@ class UioIf_PyPublishHelper : public udmaio::UioIf {
     using udmaio::UioIf::_wr32;
     using udmaio::UioIf::arm_interrupt;
     using udmaio::UioIf::read_bulk;
+    using udmaio::UioIf::write_bulk;
     using udmaio::UioIf::UioIf;
     using udmaio::UioIf::wait_for_interrupt;
 };
@@ -119,7 +120,19 @@ PYBIND11_MODULE(binding, m) {
                                         {sizeof(uint8_t)},                        // stride
                                         reinterpret_cast<uint8_t*>(vec->data()),  // data pointer
                                         gc_callback);
-        });
+        })
+        .def("write_bulk",
+             [](UioIf_PyPublishHelper& self, uint32_t offs, py::buffer b) {
+                 py::buffer_info info = b.request();
+                 // Accept only contiguous 1-D buffers
+                 if (info.ndim != 1) {
+                     throw std::runtime_error("write_bulk expects a 1-D bytes-like object");
+                 }
+                 auto ptr = static_cast<uint8_t*>(info.ptr);
+                 std::vector<uint8_t> data(ptr, ptr + info.size * info.itemsize);
+                 self.write_bulk(offs, std::move(data));
+             },
+             "Write a contiguous bytes-like object to the mapped device memory at the given offset");
 
     py::class_<udmaio::DmaBufferAbstract, std::shared_ptr<udmaio::DmaBufferAbstract>>(
         m,