maple: remove all remaining uses of the two-argument "dma_start"

After thinking about this more, I realized it is probably never useful, and
certainly completely incorrect in all of the cases it was still being used in
the examples.

example/clipping.cpp

@@ -29,8 +29,8 @@
 #include "maple/maple_bus_commands.hpp"
 #include "maple/maple_bus_ft0.hpp"
 
-uint32_t _command_buf[1024 / 4 + 32];
+uint32_t _command_buf[(1024 + 32) / 4];
-uint32_t _receive_buf[1024 / 4 + 32];
+uint32_t _receive_buf[(1024 + 32) / 4];
 
 static ft0::data_transfer::data_format data[4];
 
@@ -44,14 +44,16 @@ void do_get_condition(uint32_t * command_buf,
     .function_type = std::byteswap(function_type::controller)
   };
 
-  const uint32_t size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
+  const uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
                                                                                         data_fields);
-  maple::dma_start(command_buf, size);
+  using host_response_type = struct maple::command_response<response_type::data_fields>;
+  auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
+
+  maple::dma_start(command_buf, command_size,
+                   receive_buf, maple::sizeof_command(host_response));
 
-  using command_response_type = struct maple::command_response<response_type::data_fields>;
   for (uint8_t port = 0; port < 4; port++) {
-    auto response = reinterpret_cast<command_response_type *>(receive_buf);
+    auto& bus_data = host_response[port].bus_data;
-    auto& bus_data = response[port].bus_data;
     if (bus_data.command_code != response_type::command_code) {
       return;
     }

example/clipping2.cpp

@@ -30,8 +30,10 @@
 #include "maple/maple_bus_commands.hpp"
 #include "maple/maple_bus_ft0.hpp"
 
-uint32_t _command_buf[1024 / 4 + 32];
+#include "sh7091/serial.hpp"
-uint32_t _receive_buf[1024 / 4 + 32];
+
+uint32_t _command_buf[(1024 + 32) / 4];
+uint32_t _receive_buf[(1024 + 32) / 4];
 
 static ft0::data_transfer::data_format data[4];
 
@@ -45,14 +47,15 @@ void do_get_condition(uint32_t * command_buf,
     .function_type = std::byteswap(function_type::controller)
   };
 
-  const uint32_t size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
+  const uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
                                                                                         data_fields);
-  maple::dma_start(command_buf, size);
+  using host_response_type = struct maple::command_response<response_type::data_fields>;
+  auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
+  maple::dma_start(command_buf, command_size,
+                   receive_buf, maple::sizeof_command(host_response));
 
-  using command_response_type = struct maple::command_response<response_type::data_fields>;
   for (uint8_t port = 0; port < 4; port++) {
-    auto response = reinterpret_cast<command_response_type *>(receive_buf);
+    auto& bus_data = host_response[port].bus_data;
-    auto& bus_data = response[port].bus_data;
     if (bus_data.command_code != response_type::command_code) {
       return;
     }
@@ -249,6 +252,9 @@ void main()
 
   while (1) {
     do_get_condition(command_buf, receive_buf);
+    if (frame_ix % 120 == 0) {
+      serial::integer(data[0].analog_axis_3);
+    }
 
     ta_polygon_converter_init(opb_size.total(),
 			      ta_alloc,

example/clipping_textured.cpp

@@ -34,8 +34,8 @@
 #include "twiddle.hpp"
 #include "macaw.hpp"
 
-uint32_t _command_buf[1024 / 4 + 32];
+uint32_t _command_buf[(1024 + 32) / 4];
-uint32_t _receive_buf[1024 / 4 + 32];
+uint32_t _receive_buf[(1024 + 32) / 4];
 
 static ft0::data_transfer::data_format data[4];
 
@@ -49,9 +49,12 @@ void do_get_condition(uint32_t * command_buf,
     .function_type = std::byteswap(function_type::controller)
   };
 
-  const uint32_t size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
+  const uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
                                                                                         data_fields);
-  maple::dma_start(command_buf, size);
+  using host_response_type = struct maple::command_response<response_type::data_fields>;
+  auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
+  maple::dma_start(command_buf, command_size,
+                   receive_buf, maple::sizeof_command(host_response));
 
   using command_response_type = struct maple::command_response<response_type::data_fields>;
   for (uint8_t port = 0; port < 4; port++) {

example/maple_analog.cpp

@@ -29,8 +29,8 @@
 #include "maple/maple_bus_commands.hpp"
 #include "maple/maple_bus_ft0.hpp"
 
-uint32_t _command_buf[1024 / 4 + 32];
+uint32_t _command_buf[(1024 + 32) / 4];
-uint32_t _receive_buf[1024 / 4 + 32];
+uint32_t _receive_buf[(1024 + 32) / 4];
 
 static ft0::data_transfer::data_format data[4];
 
@@ -44,14 +44,16 @@ void do_get_condition(uint32_t * command_buf,
     .function_type = std::byteswap(function_type::controller)
   };
 
-  const uint32_t size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
+  const uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
                                                                                         data_fields);
-  maple::dma_start(command_buf, size);
+  using host_response_type = struct maple::command_response<response_type::data_fields>;
+  auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
+
+  maple::dma_start(command_buf, command_size,
+                   receive_buf, maple::sizeof_command(host_response));
 
-  using command_response_type = struct maple::command_response<response_type::data_fields>;
   for (uint8_t port = 0; port < 4; port++) {
-    auto response = reinterpret_cast<command_response_type *>(receive_buf);
+    auto& bus_data = host_response[port].bus_data;
-    auto& bus_data = response[port].bus_data;
     if (bus_data.command_code != response_type::command_code) {
       return;
     }

example/maple_controller.cpp

@@ -10,8 +10,8 @@
 #include "maple/maple_bus_ft0.hpp"
 #include "sh7091/serial.hpp"
 
-uint32_t _command_buf[1024 / 4 + 32] = {0};
+uint32_t _command_buf[(1024 + 32) / 4];
-uint32_t _receive_buf[1024 / 4 + 32] = {0};
+uint32_t _receive_buf[(1024 + 32) / 4];
 
 static uint32_t * command_buf;
 static uint32_t * receive_buf;
@@ -42,16 +42,19 @@ void do_get_condition(uint32_t port)
     return;
   }
 
-  const uint32_t size = maple::init_get_condition(command_buf, receive_buf,
+  const uint32_t command_size = maple::init_get_condition(command_buf, receive_buf,
-                                                  destination_port,
+                                                          destination_port,
-                                                  destination_ap,
+                                                          destination_ap,
-                                                  std::byteswap(function_type::controller));
+                                                          std::byteswap(function_type::controller));
-  maple::dma_start(command_buf, size);
 
   using response_type = data_transfer<ft0::data_transfer::data_format>;
   using command_response_type = struct maple::command_response<response_type::data_fields>;
-  auto response = reinterpret_cast<command_response_type *>(receive_buf);
+  auto host_response = reinterpret_cast<command_response_type *>(receive_buf);
-  auto& bus_data = response->bus_data;
+
+  maple::dma_start(command_buf, command_size,
+                   receive_buf, maple::sizeof_command(host_response));
+
+  auto& bus_data = host_response->bus_data;
   if (bus_data.command_code != response_type::command_code) {
     return;
   }
@@ -74,11 +77,13 @@ void do_device_request()
   using command_type = device_request;
   using response_type = device_status;
 
-  const uint32_t size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf);
+  const uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf);
-  maple::dma_start(command_buf, size * 10);
+  using host_response_type = struct maple::command_response<response_type::data_fields>;
+  auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
+
+  maple::dma_start(command_buf, command_size,
+                   receive_buf, maple::sizeof_command(host_response));
 
-  using command_response_type = struct maple::command_response<response_type::data_fields>;
-  auto response = reinterpret_cast<command_response_type *>(receive_buf);
   for (uint8_t port = 0; port < 4; port++) {
     auto& bus_data = response[port].bus_data;
     auto& data_fields = response[port].bus_data.data_fields;

example/maple_device_request.cpp

@@ -5,8 +5,8 @@
 #include "maple/maple_bus_commands.hpp"
 #include "sh7091/serial.hpp"
 
-uint32_t _command_buf[1024 / 4 + 32] = {0};
+uint32_t _command_buf[(1024 + 32) / 4];
-uint32_t _receive_buf[1024 / 4 + 32] = {0};
+uint32_t _receive_buf[(1024 + 32) / 4];
 
 void main()
 {
@@ -16,16 +16,19 @@ void main()
   using command_type = device_request;
   using response_type = device_status;
 
-  uint32_t size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf);
+  uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf);
-  maple::dma_start(command_buf, size);
+
+  constexpr uint32_t host_response_size = (sizeof (maple::command_response<response_type::data_fields>));
+
+  maple::dma_start(command_buf, command_size,
+                   receive_buf, host_response_size);
 
   uint8_t * buf = reinterpret_cast<uint8_t *>(receive_buf);
   for (uint8_t port = 0; port < 4; port++) {
     serial::string("port ");
     serial::integer<uint8_t>(port);
 
-    constexpr uint32_t command_response_size = (sizeof (maple::command_response<response_type::data_fields>));
+    for (uint32_t i = 0; i < host_response_size; i++) {
-    for (uint32_t i = 0; i < command_response_size; i++) {
       serial::integer<uint8_t>(buf[port * command_response_size + i]);
     }
     serial::character('\n');

example/maple_vibrator.cpp

@@ -48,28 +48,21 @@ void do_lm_request(uint8_t port, uint8_t lm)
 			   destination_ap, get_media_info::command_code, (sizeof (struct get_media_info::data_fields)),
 			   true);
 
-  using command_type = struct maple::host_command<get_media_info::data_fields>;
+  using host_command_type = struct maple::host_command<get_media_info::data_fields>;
-  auto host_command = reinterpret_cast<command_type *>(command_buf);
+  auto host_command = reinterpret_cast<host_command_type *>(command_buf);
   auto& fields = host_command->bus_data.data_fields;
   fields.function_type = std::byteswap(function_type::vibration);
   fields.pt = std::byteswap(1 << 24);
 
-  serial::string("dma start\n");
-  const uint32_t size = (reinterpret_cast<uint32_t>(&host_command[1]) - reinterpret_cast<uint32_t>(&host_command[0]));
-  maple::dma_start(command_buf, size * 2);
-
   using response_type = data_transfer<ft8::data_transfer::data_format>;
-  using command_response_type = struct maple::command_response<response_type::data_fields>;
+  using host_response_type = struct maple::command_response<response_type::data_fields>;
-  for (uint32_t i = 0; i < (sizeof (command_response_type)) / 32; i++) {
+  auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
-    asm volatile ("ocbp @%0"
-                  :                                  // output
-                  : "r" (reinterpret_cast<uint32_t>(&receive_buf[(32 * i) / 4])) // input
-                  );
-  }
 
-  auto response = reinterpret_cast<command_response_type *>(receive_buf);
+  serial::string("dma start\n");
+  maple::dma_start(command_buf, maple::sizeof_command(host_command),
+                   receive_buf, maple::sizeof_command(host_response));
 
-  auto& bus_data = response->bus_data;
+  auto& bus_data = host_response->bus_data;
   if (bus_data.command_code != response_type::command_code) {
     serial::string("lm did not reply to vibration get_media_info: ");
     serial::integer<uint8_t>(lm);
@@ -124,18 +117,12 @@ void do_lm_request(uint8_t port, uint8_t lm)
     fields.write_in_data.freq = 0x27;
     fields.write_in_data.inc = 0x00;
 
-    const uint32_t size = (reinterpret_cast<uint32_t>(&host_command[1]) - reinterpret_cast<uint32_t>(&host_command[0]));
+    using host_response_type = struct maple::command_response<device_reply::data_fields>;
-    maple::dma_start(command_buf, size);
+    auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
+    maple::dma_start(command_buf, maple::sizeof_command(host_command),
+                     receive_buf, maple::sizeof_command(host_response));
 
-    using command_response_type = struct maple::command_response<device_reply::data_fields>;
+    auto& bus_data = host_response->bus_data;
-    for (uint32_t i = 0; i < (sizeof (command_response_type)) / 32; i++) {
-      asm volatile ("ocbp @%0"
-                    :                                  // output
-                    : "r" (reinterpret_cast<uint32_t>(&receive_buf[(32 * i) / 4])) // input
-                    );
-    }
-    auto command_response = reinterpret_cast<command_response_type *>(receive_buf);
-    auto& bus_data = command_response->bus_data;
 
     if (bus_data.command_code != device_reply::command_code) {
       serial::string("lm did not reply to vibration set_condition: ");
@@ -166,21 +153,15 @@ void do_device_request()
 {
   using command_type = device_request;
   using response_type = device_status;
+  using host_response_type = struct maple::command_response<response_type::data_fields>;
+  auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
+  const uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf);
+  maple::dma_start(command_buf, command_size,
+                   receive_buf, maple::sizeof_command(host_response));
 
-  const uint32_t size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf);
-  maple::dma_start(command_buf, size);
-
-  using command_response_type = struct maple::command_response<response_type::data_fields>;
-  for (uint32_t i = 0; i < ((sizeof (command_response_type)) * 4) / 32; i++) {
-    asm volatile ("ocbp @%0"
-                  :                                  // output
-                  : "r" (reinterpret_cast<uint32_t>(&receive_buf[(32 * i) / 4])) // input
-                  );
-  }
-  auto response = reinterpret_cast<command_response_type *>(receive_buf);
   for (uint8_t port = 0; port < 4; port++) {
-    auto& bus_data = response[port].bus_data;
+    auto& bus_data = host_response[port].bus_data;
-    auto& data_fields = response[port].bus_data.data_fields;
+    auto& data_fields = bus_data.data_fields;
     if (bus_data.command_code != device_status::command_code) {
       // the controller is disconnected
     } else {
@@ -194,11 +175,11 @@ void do_device_request()
   }
 }
 
+uint32_t _command_buf[(1024 + 32) / 4];
+uint32_t _receive_buf[(1024 + 32) / 4];
+
 void main()
 {
-  uint32_t _command_buf[1024 / 4 + 32];
-  uint32_t _receive_buf[1024 / 4 + 32];
-
   command_buf = align_32byte(_command_buf);
   command_buf = reinterpret_cast<uint32_t *>(reinterpret_cast<uint32_t>(command_buf) | 0xa000'0000);
   receive_buf = align_32byte(_receive_buf);

example/maple_wink.cpp

@@ -1,6 +1,7 @@
 #include <cstdint>
 
 #include "maple/maple.hpp"
+#include "maple/maple_bus_commands.hpp"
 #include "maple/maple_bus_bits.hpp"
 #include "vga.hpp"
 #include "align.hpp"
@@ -30,26 +31,32 @@ constexpr uint32_t height = 32;
 constexpr uint32_t pixels_per_byte = 8;
 constexpr uint32_t wink_size = width * height / pixels_per_byte;
 
+uint32_t _command_buf[(1024 + 32) / 4];
+uint32_t _receive_buf[(1024 + 32) / 4];
+
 void main()
 {
   uint32_t wink_buf[wink_size / 4];
   make_wink(wink_buf);
 
-  uint32_t _command_buf[(1024 + 32) / 4];
-  uint32_t _receive_buf[(1024 + 32) / 4];
   uint32_t * command_buf = align_32byte(_command_buf);
   uint32_t * receive_buf = align_32byte(_receive_buf);
 
-  const uint32_t size = maple::init_block_write(command_buf, receive_buf,
+  const uint32_t command_size = maple::init_block_write(command_buf, receive_buf,
-                                                host_instruction::port_select::a,
+                                                        host_instruction::port_select::a,
-                                                ap::de::expansion_device | ap::port_select::a | ap::lm_bus::_0,
+                                                        ap::de::expansion_device | ap::port_select::a | ap::lm_bus::_0,
-                                                wink_buf,
+                                                        wink_buf,
-                                                wink_size);
+                                                        wink_size);
-  maple::dma_start(command_buf, size);
+  using response_type = device_reply;
+  using host_response_type = struct maple::command_response<response_type::data_fields>;
+  auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
+  maple::dma_start(command_buf, command_size,
+                   receive_buf, maple::sizeof_command(host_response));
 
-  for (int i = 0; i < 1; i++) {
+  serial::integer<uint8_t>(host_response->bus_data.command_code);
-    serial::integer<uint32_t>(receive_buf[i]);
+  serial::integer<uint8_t>(host_response->bus_data.destination_ap);
-  }
+  serial::integer<uint8_t>(host_response->bus_data.source_ap);
+  serial::integer<uint8_t>(host_response->bus_data.data_size);
 
   vga();
   v_sync_in();

example/modifier_volume_with_two_volumes.cpp

@@ -45,14 +45,16 @@ void do_get_condition(uint32_t * command_buf,
     .function_type = std::byteswap(function_type::controller)
   };
 
-  const uint32_t size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
+  const uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
-                                                                                        data_fields);
+                                                                                                data_fields);
-  maple::dma_start(command_buf, size);
+  using host_response_type = struct maple::command_response<response_type::data_fields>;
+  auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
+
+  maple::dma_start(command_buf, command_size,
+                   receive_buf, maple::sizeof_command(host_response));
 
-  using command_response_type = struct maple::command_response<response_type::data_fields>;
   for (uint8_t port = 0; port < 4; port++) {
-    auto response = reinterpret_cast<command_response_type *>(receive_buf);
+    auto& bus_data = host_response[port].bus_data;
-    auto& bus_data = response[port].bus_data;
     if (bus_data.command_code != response_type::command_code) {
       return;
     }
@@ -341,8 +343,8 @@ void update_rot_pos(struct rot_pos& rot_pos)
 }
 
 uint32_t _ta_parameter_buf[((32 * 8192) + 32) / 4];
-uint32_t _command_buf[1024 / 4 + 32];
+uint32_t _command_buf[(1024 + 32) / 4];
-uint32_t _receive_buf[1024 / 4 + 32];
+uint32_t _receive_buf[(1024 + 32) / 4];
 
 void main()
 {

maple/maple.cpp

@@ -105,17 +105,10 @@ uint32_t init_block_write(uint32_t * command_buf, uint32_t * receive_buf,
     + data_size;
 }
 
-void dma_start(const uint32_t * command_buf, const uint32_t size)
+static inline void _dma_start(const uint32_t * command_buf)
 {
   using namespace dmac;
 
-  for (uint32_t i = 0; i < align_32byte(size) / 32; i++) {
-    asm volatile ("ocbwb @%0"
-                  :                                  // output
-                  : "r" (reinterpret_cast<uint32_t>(&command_buf[(32 * i) / 4])) // input
-                  );
-  }
-
   //command_buf = reinterpret_cast<uint32_t *>(reinterpret_cast<uint32_t>(command_buf) | 0xa000'0000);
 
   sh7091.DMAC.DMAOR = dmaor::ddt::on_demand_data_transfer_mode       /* on-demand data transfer mode */
@@ -148,6 +141,37 @@ void dma_start(const uint32_t * command_buf, const uint32_t size)
 
   maple_if.MDEN = mden::dma_enable::enable;
   maple_if.MDST = mdst::start_status::start;
+}
+
+void dma_start(const uint32_t * command_buf,
+               const uint32_t command_size,
+               const uint32_t * receive_buf,
+               const uint32_t receive_size
+               )
+{
+  // write back operand cache blocks for command buffer prior to starting DMA
+  for (uint32_t i = 0; i < align_32byte(command_size) / 32; i++) {
+    asm volatile ("ocbwb @%0"
+                  :                                                              // output
+                  : "r" (reinterpret_cast<uint32_t>(&command_buf[(32 * i) / 4])) // input
+                  );
+  }
+
+  // start maple DMA
+  _dma_start(command_buf);
+
+  // purge operand cache block for receive buffer, prior to returning to the caller
+  for (uint32_t i = 0; i < align_32byte(receive_size) / 32; i++) {
+    asm volatile ("ocbp @%0"
+                  :                                                              // output
+                  : "r" (reinterpret_cast<uint32_t>(&receive_buf[(32 * i) / 4])) // input
+                  );
+  }
+
+  // wait for maple DMA completion
+  while ((system.ISTNRM & ISTNRM__END_OF_DMA_MAPLE_DMA) == 0);
+  system.ISTNRM = ISTNRM__END_OF_DMA_MAPLE_DMA;
+}
 
   // wait for completion
   //while (mdst::start_status::status(maple_if.MDST) != 0);
@@ -163,8 +187,5 @@ void dma_start(const uint32_t * command_buf, const uint32_t size)
     }
   }
   */
-  while ((system.ISTNRM & ISTNRM__END_OF_DMA_MAPLE_DMA) == 0);
-  system.ISTNRM = ISTNRM__END_OF_DMA_MAPLE_DMA;
-}
 
 }

maple/maple.hpp

@@ -54,6 +54,16 @@ uint32_t init_block_write(uint32_t * buf, uint32_t * receive_buf,
                           uint32_t * data,
                           uint32_t data_size);
 
-void dma_start(const uint32_t * command_buf, const uint32_t size);
+void dma_start(const uint32_t * command_buf,
+               const uint32_t command_size,
+               const uint32_t * receive_buf,
+               const uint32_t receive_size
+               );
+
+template <typename T>
+constexpr uint32_t sizeof_command(T * c)
+{
+  return reinterpret_cast<uint32_t>(&c[1]) - reinterpret_cast<uint32_t>(&c[0]);
+}
 
 }