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

@@ -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,6 +30,8 @@
 #include "maple/maple_bus_commands.hpp"
 #include "maple/maple_bus_ft0.hpp"
 
+#include "sh7091/serial.hpp"
+
 uint32_t _command_buf[(1024 + 32) / 4];
 uint32_t _receive_buf[(1024 + 32) / 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

@@ -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

@@ -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

@@ -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

@@ -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/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;
     }

maple/maple.cpp

@@ -173,26 +173,6 @@ void dma_start(const uint32_t * command_buf,
   system.ISTNRM = ISTNRM__END_OF_DMA_MAPLE_DMA;
 }
 
-void dma_start(const uint32_t * command_buf,
-               const uint32_t command_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);
-
-  // 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);
   /*

maple/maple.hpp

@@ -60,10 +60,6 @@ void dma_start(const uint32_t * command_buf,
                const uint32_t receive_size
                );
 
-void dma_start(const uint32_t * command_buf,
-               const uint32_t command_size
-               );
-
 template <typename T>
 constexpr uint32_t sizeof_command(T * c)
 {