bilbo/dreamcast
1
0
Fork 0
Code Pull Requests Activity

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

Browse Source 
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.
This commit is contained in:
Zack Buhman 2024-02-03 10:15:39 +08:00
parent dfc14d8658
commit 31eb0df508
9 changed files with 61 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
example/clipping.cpp
View File

@ -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 = response[port].bus_data;
auto& bus_data = host_response[port].bus_data;
if (bus_data.command_code != response_type::command_code) {
return;
}

16
example/clipping2.cpp
View File

@ -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 = response[port].bus_data;
auto& bus_data = host_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,

7
example/clipping_textured.cpp
View File

@ -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++) {

12
example/maple_analog.cpp
View File

@ -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 = response[port].bus_data;
auto& bus_data = host_response[port].bus_data;
if (bus_data.command_code != response_type::command_code) {
return;
}

27
example/maple_controller.cpp
View File

@ -42,16 +42,19 @@ void do_get_condition(uint32_t port)
return;
}
const uint32_t size = maple::init_get_condition(command_buf, receive_buf,
destination_port,
destination_ap,
std::byteswap(function_type::controller));
maple::dma_start(command_buf, size);
const uint32_t command_size = maple::init_get_condition(command_buf, receive_buf,
destination_port,
destination_ap,
std::byteswap(function_type::controller));
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& bus_data = response->bus_data;
auto host_response = reinterpret_cast<command_response_type *>(receive_buf);
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);
maple::dma_start(command_buf, size * 10);
const uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf);
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;

11
example/maple_device_request.cpp
View File

@ -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);
maple::dma_start(command_buf, size);
uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf);
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 < command_response_size; i++) {
for (uint32_t i = 0; i < host_response_size; i++) {
serial::integer<uint8_t>(buf[port * command_response_size + i]);
}
serial::character('\n');

14
example/modifier_volume_with_two_volumes.cpp
View File

@ -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,
data_fields);
maple::dma_start(command_buf, size);
const uint32_t command_size = maple::init_host_command_all_ports<command_type, response_type>(command_buf, receive_buf,
data_fields);
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 = response[port].bus_data;
auto& bus_data = host_response[port].bus_data;
if (bus_data.command_code != response_type::command_code) {
return;
}

20
maple/maple.cpp
View File

@ -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);
/*

4
maple/maple.hpp
View File

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