bilbo/dreamcast
1
0
Fork 0
Code Pull Requests Activity

maple: move ocbp inline assembly to dma_start

Browse Source 
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.
This commit is contained in:
Zack Buhman 2024-02-03 09:52:21 +08:00
parent 511d99563d
commit dfc14d8658
11 changed files with 122 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
example/clipping.cpp
View File

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

4
example/clipping2.cpp
View File

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

4
example/clipping_textured.cpp
View File

@ -34,8 +34,8 @@
#include "twiddle.hpp"
#include "macaw.hpp"
uint32_t _command_buf[1024 / 4 + 32];
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];

4
example/maple_analog.cpp
View File

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

4
example/maple_controller.cpp
View File

@ -10,8 +10,8 @@
#include "maple/maple_bus_ft0.hpp"
#include "sh7091/serial.hpp"
uint32_t _command_buf[1024 / 4 + 32] = {0};
uint32_t _receive_buf[1024 / 4 + 32] = {0};
uint32_t _command_buf[(1024 + 32) / 4];
uint32_t _receive_buf[(1024 + 32) / 4];
static uint32_t * command_buf;
static uint32_t * receive_buf;

4
example/maple_device_request.cpp
View File

@ -5,8 +5,8 @@
#include "maple/maple_bus_commands.hpp"
#include "sh7091/serial.hpp"
uint32_t _command_buf[1024 / 4 + 32] = {0};
uint32_t _receive_buf[1024 / 4 + 32] = {0};
uint32_t _command_buf[(1024 + 32) / 4];
uint32_t _receive_buf[(1024 + 32) / 4];
void main()
{

65
example/maple_vibrator.cpp
View File

@ -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>;
auto host_command = reinterpret_cast<command_type *>(command_buf);
using host_command_type = struct maple::host_command<get_media_info::data_fields>;
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>;
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
);
}
using host_response_type = struct maple::command_response<response_type::data_fields>;
auto host_response = reinterpret_cast<host_response_type *>(receive_buf);
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]));
maple::dma_start(command_buf, size);
using host_response_type = struct maple::command_response<device_reply::data_fields>;
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>;
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;
auto& bus_data = host_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& data_fields = response[port].bus_data.data_fields;
auto& bus_data = host_response[port].bus_data;
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);

21
example/maple_wink.cpp
View File

@ -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<uint32_t>(receive_buf[i]);
}
serial::integer<uint8_t>(host_response->bus_data.command_code);
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();

4
example/modifier_volume_with_two_volumes.cpp
View File

@ -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 _receive_buf[1024 / 4 + 32];
uint32_t _command_buf[(1024 + 32) / 4];
uint32_t _receive_buf[(1024 + 32) / 4];
void main()
{

63
maple/maple.cpp
View File

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

16
maple/maple.hpp
View File

@ -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]);
}
}