TheArchive/mayhem-firmware
1
0
Fork 0
mirror of https://github.com/portapack-mayhem/mayhem-firmware.git synced 2025-08-23 14:57:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

implemented scsi inquiry

Browse Source
This commit is contained in:
Bernd Herzog
2023-03-31 19:18:39 +02:00
parent a6eb430830
commit 776ac652a8
9 changed files with 1070 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
firmware/baseband/sd_over_usb/sd_over_usb.c
View File

@@ -1,102 +1,175 @@
#include "sd_over_usb.h"
#include "scsi.h"
//extern usb_request_handlers_t usb_request_handlers;
#define HALT_UNTIL_DEBUGGING() \
while (!((*(volatile uint32_t *)0xE000EDF0) & (1 << 0))) {} \
__asm__ __volatile__("bkpt 1")
// uint8_t usb_buffer[USB_TRANSFER_SIZE];
usb_request_status_t dummy(
bool scsi_running = false;
usb_request_status_t report_max_lun(
usb_endpoint_t* const endpoint,
const usb_transfer_stage_t stage)
{
if (stage == USB_TRANSFER_STAGE_SETUP) {
endpoint->buffer[0] = 0;
usb_transfer_schedule_block(
endpoint->in,
&endpoint->buffer,
1,
NULL,
NULL);
usb_transfer_schedule_ack(endpoint->out);
/* start loop here?*/
scsi_running = true;
// Host to Device. receive inquiry LUN
return USB_REQUEST_STATUS_OK;
}
else if (stage == USB_TRANSFER_STAGE_DATA) {
return USB_REQUEST_STATUS_OK;
}
else if (stage == USB_TRANSFER_STAGE_STATUS) {
// response here?
return USB_REQUEST_STATUS_OK;
}
}
usb_request_status_t report_magic_scsi(
usb_endpoint_t* const endpoint,
const usb_transfer_stage_t stage)
{
// return USB_REQUEST_STATUS_OK;
// if (endpoint->address != 0x02) {
// HALT_UNTIL_DEBUGGING();
// return USB_REQUEST_STATUS_OK;
// }
if (stage == USB_TRANSFER_STAGE_SETUP) {
return USB_REQUEST_STATUS_OK;
// usb_bulk_buffer[0] = 0x55;
// usb_bulk_buffer[1] = 0x55;
// usb_bulk_buffer[2] = 0x55;
// usb_bulk_buffer[3] = 0x55;
// usb_bulk_buffer[4] = 0;
// usb_transfer_schedule_block(
// &usb_endpoint_bulk_out,
// &usb_bulk_buffer[0x0000],
// 5,
// NULL,
// NULL);
// usb_transfer_schedule_ack(endpoint->out);
}
else if (stage == USB_TRANSFER_STAGE_DATA) {
HALT_UNTIL_DEBUGGING();
}
else if (stage == USB_TRANSFER_STAGE_STATUS) {
HALT_UNTIL_DEBUGGING();
}
return USB_REQUEST_STATUS_OK;
(void)(endpoint);
(void)(stage);
return USB_REQUEST_STATUS_OK;
}
static usb_request_handler_fn vendor_request_handler[] = {
NULL,
dummy // USB_WCID_VENDOR_REQ
};
static const uint32_t vendor_request_handler_count =
sizeof(vendor_request_handler) / sizeof(vendor_request_handler[0]);
usb_request_status_t usb_vendor_request(
usb_endpoint_t* const endpoint,
const usb_transfer_stage_t stage)
{
usb_request_status_t status = USB_REQUEST_STATUS_STALL;
if (endpoint->setup.request < vendor_request_handler_count) {
usb_request_handler_fn handler =
vendor_request_handler[endpoint->setup.request];
if (handler) {
status = handler(endpoint, stage);
}
volatile uint_fast8_t address = endpoint->address;
volatile uint8_t request = endpoint->setup.request;
volatile uint32_t b = 0;
if (request == 25) { // unknown code
return report_magic_scsi(endpoint, stage);
}
b = request + (address << 16);
HALT_UNTIL_DEBUGGING();
return status;
}
usb_request_status_t usb_class_request(
usb_endpoint_t* const endpoint,
const usb_transfer_stage_t stage)
{
usb_request_status_t status = USB_REQUEST_STATUS_STALL;
volatile uint_fast8_t address = endpoint->address;
volatile uint8_t request = endpoint->setup.request;
volatile uint32_t b = 0;
if (request == 0xFE) {
return report_max_lun(endpoint, stage);
}
b = request + (address << 16);
HALT_UNTIL_DEBUGGING();
// if (address == 0x80) {
// HALT_UNTIL_DEBUGGING();
// return USB_REQUEST_STATUS_OK;
// }
// else if (address == 0x00) {
// if (request == 0xFE) {
// return USB_REQUEST_STATUS_OK; // ???????????????????
// }
// b = request + (address << 16);
// HALT_UNTIL_DEBUGGING();
// }
// else if (address == 0x02) {
// if (request == 0xFE) {
// return USB_REQUEST_STATUS_OK; // ???????????????????
// }
// //return USB_REQUEST_STATUS_OK;
// }
// HALT_UNTIL_DEBUGGING();
return status + b;
}
const usb_request_handlers_t usb_request_handlers = {
.standard = usb_standard_request,
.class = 0,
.class = usb_class_request,
.vendor = usb_vendor_request,
.reserved = 0,
.reserved = 0
};
void usb_configuration_changed(usb_device_t* const device)
{
/* Reset transceiver to idle state until other commands are received */
// request_transceiver_mode(TRANSCEIVER_MODE_OFF);
// if (device->configuration->number == 1) {
// // transceiver configuration
// led_on(LED1);
// } else {
// /* Configuration number equal 0 means usb bus reset. */
// led_off(LED1);
// }
usb_endpoint_init(&usb_endpoint_bulk_in);
usb_endpoint_init(&usb_endpoint_bulk_out);
}
void start_usb(void) {
/* use XTAL_OSC as clock source for PLL0USB */
// CGU_PLL0USB_CTRL =
// CGU_PLL0USB_CTRL_PD(1) /* PLL0 power down */ |
// CGU_PLL0USB_CTRL_AUTOBLOCK(1) /* Block clock automatically during frequency change */ |
// CGU_PLL0USB_CTRL_CLK_SEL(CGU_SRC_XTAL); /* Clock source selection */
// while (CGU_PLL0USB_STAT & CGU_PLL0USB_STAT_LOCK_MASK) {}
/* configure PLL0USB to produce 480 MHz clock from 12 MHz XTAL_OSC */
/* Values from User Manual v1.4 Table 94, for 12MHz oscillator. */
// CGU_PLL0USB_MDIV = 0x06167FFA;
// CGU_PLL0USB_NP_DIV = 0x00302062;
// CGU_PLL0USB_CTRL |=
// CGU_PLL0USB_CTRL_PD(1) /* PLL0 power down */ |
// CGU_PLL0USB_CTRL_DIRECTI(1) /* PLL0 direct input */ |
// CGU_PLL0USB_CTRL_DIRECTO(1) /* PLL0 direct output */ |
// CGU_PLL0USB_CTRL_CLKEN(1) /* PLL0 clock enable */;
// /* power on PLL0USB and wait until stable */
// CGU_PLL0USB_CTRL &= ~CGU_PLL0USB_CTRL_PD_MASK /* PLL0 power down */ ;
// while (!(CGU_PLL0USB_STAT & CGU_PLL0USB_STAT_LOCK_MASK)) {}
/* use PLL0USB as clock source for USB0 */
// CGU_BASE_USB0_CLK = CGU_BASE_USB0_CLK_AUTOBLOCK(1) |
// CGU_BASE_USB0_CLK_CLK_SEL(CGU_SRC_PLL0USB);
detect_hardware_platform();
pin_setup();
cpu_clock_init();
usb_set_configuration_changed_cb(usb_configuration_changed);
usb_peripheral_reset();
@@ -113,16 +186,39 @@ void start_usb(void) {
nvic_set_priority(NVIC_USB0_IRQ, 255);
usb_run(&usb_device);
}
void stop_usb(void) {
usb_peripheral_reset();
}
void irq_usb(void) {
usb0_isr();
}
volatile bool transfer_complete = false;
void scsi_bulk_transfer_complete(void* user_data, unsigned int bytes_transferred)
{
transfer_complete = true;
}
void usb_transfer(void) {
if (scsi_running) {
transfer_complete = false;
usb_transfer_schedule_block(
&usb_endpoint_bulk_out,
&usb_bulk_buffer[0],
USB_TRANSFER_SIZE,
scsi_bulk_transfer_complete,
NULL);
while (!transfer_complete);
msd_cbw_t *msd_cbw_data = (msd_cbw_t *) &usb_bulk_buffer[0];
if (msd_cbw_data->signature == MSD_CBW_SIGNATURE){
scsi_command(msd_cbw_data);
}
}
}