maple: move ocbp inline assembly to dma_start

Necessarily, this means that dma_start must now know what the size of the
response is, so that it can issue the appropriate number of ocbp instructions.

This also cleans up the inconsistent _command_buf and _recieve_buf declarations.

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];
 

example/clipping2.cpp

@@ -30,8 +30,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];
 

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];
 

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];
 

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;

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()
 {

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,
                                                         ap::de::expansion_device | ap::port_select::a | ap::lm_bus::_0,
                                                         wink_buf,
                                                         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

@@ -341,8 +341,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,57 @@ 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;
+}
+
+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);
@@ -163,8 +207,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,20 @@ 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
+               );
+
+void dma_start(const uint32_t * command_buf,
+               const uint32_t command_size
+               );
+
+template <typename T>
+constexpr uint32_t sizeof_command(T * c)
+{
+  return reinterpret_cast<uint32_t>(&c[1]) - reinterpret_cast<uint32_t>(&c[0]);
+}
 
 }