osd-contiki/cpu/arm/common/usb/msc/usb-msc-bulk.c

530 lines
14 KiB
C
Raw Normal View History

2009-07-11 16:43:13 +02:00
#include "usb-msc-bulk.h"
#include <usb-api.h>
#include <usb-core.h>
#include <sys/process.h>
#include <stdio.h>
#include <string.h>
#define DEBUG
#ifdef DEBUG
#define PRINTF(...) printf(__VA_ARGS__)
#else
#define PRINTF(...)
#endif
static const uint8_t max_lun = 0;
static USBBuffer data_usb_buffer[USB_MSC_BUFFERS];
static unsigned int buffer_lengths[USB_MSC_BUFFERS];
static unsigned int buf_first = 0; /* First prepared buffer */
static unsigned int buf_free = 0; /* First free buffer */
static unsigned int buf_submitted = 0; /* Oldest submitted buffer */
#define USB_BUFFER_ID_UNUSED 0
#define USB_BUFFER_ID_CBW 1
#define USB_BUFFER_ID_CSW 2
#define USB_BUFFER_ID_DATA 3
#define USB_BUFFER_ID_DISCARD 4
#define USB_BUFFER_ID_HALT 5
#define USB_BUFFER_ID_MASK 0x07
static struct usb_msc_bulk_cbw cbw_buffer;
static struct usb_msc_bulk_csw csw_buffer;
#define BULK_OUT 0x02
#define BULK_IN 0x81
PROCESS(usb_mass_bulk_process, "USB mass storage bulk only process");
static process_event_t reset_event;
static struct usb_msc_command_state state;
/* Handle wrapping */
#define PREV_BUF(x) (((x) == 0) ? USB_MSC_BUFFERS - 1 : (x) - 1)
#define NEXT_BUF(x) (((x) < (USB_MSC_BUFFERS-1)) ? (x) + 1 : 0)
void
usb_msc_send_data_buf_flags(const uint8_t *data, unsigned int len,
unsigned int flags, uint16_t buf_flags)
{
USBBuffer *buffer = &data_usb_buffer[buf_free];
if (buffer->id != USB_BUFFER_ID_UNUSED) {
printf("Data IN buffer busy\n");
return;
}
buffer->flags = USB_BUFFER_NOTIFY | buf_flags;
buffer->next = NULL;
buffer->data = (uint8_t*)data;
buffer->left = len;
buffer_lengths[buf_free] = len;
buffer->id = USB_BUFFER_ID_DATA | flags;
if (buf_free != buf_first) {
data_usb_buffer[PREV_BUF(buf_free)].next = buffer;
}
state.cmd_data_submitted += len;
buf_free = NEXT_BUF(buf_free);
/* PRINTF("usb_msc_send_data: %d\n", len); */
if (flags & USB_MSC_DATA_SEND) {
usb_submit_xmit_buffer(BULK_IN, &data_usb_buffer[buf_first]);
buf_first = buf_free;
/* PRINTF("usb_msc_send_data: sent\n"); */
} else if (flags & USB_MSC_DATA_LAST) {
/* Cancel transmission */
buf_first = buf_free;
process_poll(&usb_mass_bulk_process);
}
}
void
usb_msc_send_data(const uint8_t *data, unsigned int len, unsigned int flags)
{
usb_msc_send_data_buf_flags(data, len, flags,0);
}
void
usb_msc_receive_data_buf_flags(uint8_t *data, unsigned int len,
unsigned int flags, uint16_t buf_flags)
{
USBBuffer *buffer = &data_usb_buffer[buf_free];
if (buffer->id != USB_BUFFER_ID_UNUSED) {
printf("Data IN buffer busy\n");
return;
}
buffer->flags = USB_BUFFER_NOTIFY | buf_flags;
buffer->next = NULL;
buffer->data = data;
buffer->left = len;
buffer_lengths[buf_free] = len;
buffer->id = USB_BUFFER_ID_DATA | flags;
if (buf_free != buf_first) {
data_usb_buffer[PREV_BUF(buf_free)].next = buffer;
}
state.cmd_data_submitted += len;
buf_free = NEXT_BUF(buf_free);
if (flags & USB_MSC_DATA_RECEIVE) {
usb_submit_recv_buffer(BULK_OUT, &data_usb_buffer[buf_first]);
buf_first = buf_free;
} else if (flags & USB_MSC_DATA_LAST) {
usb_discard_all_buffers(BULK_OUT);
/* Mark the discarded buffers as unused */
while(buf_submitted != PREV_BUF(buf_free)) {
data_usb_buffer[buf_submitted].id = USB_BUFFER_ID_UNUSED;
buf_submitted = NEXT_BUF(buf_submitted);
}
buf_first = buf_free;
process_poll(&usb_mass_bulk_process);
}
}
void
usb_msc_receive_data(uint8_t *data, unsigned int len, unsigned int flags)
{
usb_msc_receive_data_buf_flags(data,len,flags, 0);
}
static unsigned int
handle_mass_bulk_requests()
{
switch(usb_setup_buffer.bmRequestType) {
case 0x21: /* interface OUT requests */
switch(usb_setup_buffer.bRequest) {
case MASS_BULK_RESET:
PRINTF("Mass storage reset\n");
process_post(&usb_mass_bulk_process, reset_event, NULL);
return 1;
}
break;
case 0xa1: /* interface IN requests */
switch(usb_setup_buffer.bRequest) {
case MASS_BULK_GET_MAX_LUN:
PRINTF("Get LUN\n");
usb_send_ctrl_response(&max_lun, sizeof(max_lun));
return 1;
}
break;
}
return 0;
}
static const struct USBRequestHandler mass_bulk_request_handler =
{
0x21, 0x7f,
0x00, 0x00,
handle_mass_bulk_requests
};
static struct USBRequestHandlerHook mass_bulk_request_hook =
{
NULL,
&mass_bulk_request_handler
};
static void
send_csw(void)
{
USBBuffer *buffer = &data_usb_buffer[buf_free];
if (buffer->id != USB_BUFFER_ID_UNUSED) {
printf("CSW buffer busy\n");
return;
}
csw_buffer.dCSWSignature = MASS_BULK_CSW_SIGNATURE;
csw_buffer.dCSWTag = cbw_buffer.dCBWTag;
csw_buffer.dCSWDataResidue =
cbw_buffer.dCBWDataTransferLength - state.cmd_data_submitted;
csw_buffer.bCSWStatus = state.status;
buffer->flags = USB_BUFFER_NOTIFY;
buffer->next = NULL;
buffer->data =(uint8_t*)&csw_buffer ;
buffer->left = sizeof(csw_buffer);
buffer->id = USB_BUFFER_ID_CSW;
if (buf_free != buf_first) {
data_usb_buffer[PREV_BUF(buf_free)].next = buffer;
}
buf_free = NEXT_BUF(buf_free);
usb_submit_xmit_buffer(BULK_IN, &data_usb_buffer[buf_first]);
buf_first = buf_free;
PRINTF("CSW sent: %ld\n", sizeof(csw_buffer));
}
static void
submit_cbw_buffer(void)
{
USBBuffer *buffer = &data_usb_buffer[buf_free];
if (buffer->id != USB_BUFFER_ID_UNUSED) {
printf("CBW buffer busy\n");
return;
}
buffer->flags = USB_BUFFER_NOTIFY;
buffer->next = NULL;
buffer->data = (uint8_t*)&cbw_buffer;
buffer->left = sizeof(cbw_buffer);
buffer->id = USB_BUFFER_ID_CBW;
if (buf_free != buf_first) {
data_usb_buffer[PREV_BUF(buf_free)].next = buffer;
}
buf_free = NEXT_BUF(buf_free);
usb_submit_recv_buffer(BULK_OUT, &data_usb_buffer[buf_first]);
PRINTF("CBW submitted: %d\n", buf_first);
buf_first = buf_free;
}
static void
submit_halt(uint8_t addr)
{
USBBuffer *buffer = &data_usb_buffer[buf_free];
if (buffer->id != USB_BUFFER_ID_UNUSED) {
printf("CBW buffer busy\n");
return;
}
buffer->flags = USB_BUFFER_NOTIFY | USB_BUFFER_HALT;
buffer->next = NULL;
buffer->data = NULL;
buffer->left = 0;
buffer->id = USB_BUFFER_ID_HALT;
if (buf_free != buf_first) {
data_usb_buffer[PREV_BUF(buf_free)].next = buffer;
}
buf_free = NEXT_BUF(buf_free);
if (addr & 0x80) {
usb_submit_xmit_buffer(addr, &data_usb_buffer[buf_first]);
} else {
usb_submit_recv_buffer(addr, &data_usb_buffer[buf_first]);
}
PRINTF("HALT submitted %p\n",buffer);
buf_first = buf_free;
}
static USBBuffer *
get_next_buffer(uint8_t addr, uint32_t id)
{
unsigned int events;
events = usb_get_ep_events(addr);
if (events & USB_EP_EVENT_NOTIFICATION) {
USBBuffer *buffer = &data_usb_buffer[buf_submitted];
if (!(buffer->flags & USB_BUFFER_SUBMITTED)) {
#ifdef DEBUG
if (id != (buffer->id & USB_BUFFER_ID_MASK)) {
printf("Wrong buffer ID expected %d, got %d\n",
(int)id, (int)buffer->id);
}
#endif
if ((buffer->id & USB_BUFFER_ID_MASK) == USB_BUFFER_ID_DATA) {
state.cmd_data_transfered +=
buffer_lengths[buf_submitted] - buffer->left;
}
buffer->id = USB_BUFFER_ID_UNUSED;
buf_submitted =NEXT_BUF(buf_submitted);
return buffer;
}
}
return NULL;
}
PROCESS(usb_mass_bulk_request_process, "USB mass storage request process");
PROCESS_THREAD(usb_mass_bulk_request_process, ev , data)
{
PROCESS_BEGIN();
reset_state:
usb_discard_all_buffers(BULK_OUT);
usb_discard_all_buffers(BULK_IN);
memset(data_usb_buffer, 0, sizeof(data_usb_buffer));
buf_first = 0;
buf_free = 0;
buf_submitted = 0;
submit_cbw_buffer();
receive_cbw_state:
PRINTF("receive_cbw_state\n");
while(1) {
PROCESS_WAIT_EVENT();
if (ev == reset_event) goto reset_state;
if (ev == PROCESS_EVENT_POLL) {
USBBuffer *buffer;
if ((buffer = get_next_buffer(BULK_OUT, USB_BUFFER_ID_CBW))) {
/* CBW */
if (cbw_buffer.dCBWSignature == MASS_BULK_CBW_SIGNATURE) {
usb_msc_handler_status ret;
PRINTF("Got CBW seq %d\n",(int)cbw_buffer.dCBWTag);
state.command = cbw_buffer.CBWCB;
state.command_length = cbw_buffer.bCBWCBLength;
state.status = MASS_BULK_CSW_STATUS_FAILED;
state.data_cb = NULL;
state.cmd_data_submitted = 0;
state.cmd_data_transfered = 0;
ret = usb_msc_handle_command(&state);
if (ret == USB_MSC_HANDLER_OK) {
state.status = MASS_BULK_CSW_STATUS_PASSED;
} else if (ret == USB_MSC_HANDLER_FAILED) {
state.status = MASS_BULK_CSW_STATUS_FAILED;
}
if (ret != USB_MSC_HANDLER_DELAYED
&& buf_submitted == buf_free) {
if (cbw_buffer.dCBWDataTransferLength > 0) {
/* HALT the apropriate endpoint */
if (cbw_buffer.bmCBWFlags & MASS_BULK_CBW_FLAG_IN) {
submit_halt(BULK_IN);
} else {
submit_halt(BULK_OUT);
}
/* Wait for HALT */
while(1) {
PROCESS_WAIT_EVENT();
if (ev == reset_event) goto reset_state;
if (ev == PROCESS_EVENT_POLL) {
USBBuffer *buffer =
get_next_buffer(BULK_IN, USB_BUFFER_ID_HALT);
if (buffer && (buffer->flags & USB_BUFFER_HALT)) break;
}
}
}
goto send_csw_state;
}
2009-07-11 16:43:13 +02:00
if (cbw_buffer.bmCBWFlags & MASS_BULK_CBW_FLAG_IN) {
goto send_data_state;
} else {
goto receive_data_state;
}
} else {
printf("Invalid CBW\n");
submit_halt(BULK_IN);
submit_halt(BULK_OUT);
while(1) {
PROCESS_WAIT_EVENT();
if (ev == reset_event) goto reset_state;
if (ev == PROCESS_EVENT_POLL) {
USBBuffer *buffer = get_next_buffer(BULK_IN, USB_BUFFER_ID_HALT);
if (buffer && (buffer->flags & USB_BUFFER_HALT)) break;
}
}
while(1) {
PROCESS_WAIT_EVENT();
if (ev == reset_event) goto reset_state;
if (ev == PROCESS_EVENT_POLL) {
USBBuffer *buffer = get_next_buffer(BULK_OUT, USB_BUFFER_ID_HALT);
if (buffer && (buffer->flags & USB_BUFFER_HALT)) break;
}
}
/* CBW */
goto receive_cbw_state;
}
}
}
}
send_data_state:
PRINTF("send_data_state\n");
while(1) {
uint8_t id = 0;
/* Wait for any data to be sent */
while (buf_submitted == buf_free) {
PROCESS_WAIT_EVENT();
}
#if 0
/* Send CSW early to improve throughput, unless we need to HALT
the endpoint due to short data */
if ((data_usb_buffer[PREV_BUF(buf_free)].id & USB_MSC_DATA_LAST)
&& state.cmd_data_submitted == cbw_buffer.dCBWDataTransferLength) {
send_csw();
}
#endif
/* Wait until the current buffer is free */
while (data_usb_buffer[buf_submitted].flags & USB_BUFFER_SUBMITTED) {
PROCESS_WAIT_EVENT();
}
while (!(data_usb_buffer[buf_submitted].flags & USB_BUFFER_SUBMITTED)) {
id = data_usb_buffer[buf_submitted].id;
/* PRINTF("id: %02x\n", id); */
if (id == USB_BUFFER_ID_UNUSED) break;
state.cmd_data_transfered += buffer_lengths[buf_submitted];
data_usb_buffer[buf_submitted].id = USB_BUFFER_ID_UNUSED;
buf_submitted =NEXT_BUF(buf_submitted);
if (id & USB_MSC_DATA_DO_CALLBACK) {
if (state.data_cb) {
state.data_cb(&state);
}
}
if (id & USB_MSC_DATA_LAST) {
break;
}
}
if (id & USB_MSC_DATA_LAST) {
break;
}
}
if (state.cmd_data_submitted < cbw_buffer.dCBWDataTransferLength) {
submit_halt(BULK_IN);
while(1) {
PROCESS_WAIT_EVENT();
if (ev == reset_event) goto reset_state;
if (ev == PROCESS_EVENT_POLL) {
USBBuffer *buffer = get_next_buffer(BULK_IN , USB_BUFFER_ID_HALT);
if (buffer) {
if (buffer->flags & USB_BUFFER_HALT) break;
}
}
}
}
goto send_csw_state;
receive_data_state:
PRINTF("receive_data_state\n");
while(1) {
uint8_t id = 0;
/* Wait for any buffers to be submitted */
while (buf_submitted == buf_free) {
PROCESS_WAIT_EVENT();
}
/* Wait until the current buffer is free */
while (data_usb_buffer[buf_submitted].flags & USB_BUFFER_SUBMITTED) {
PROCESS_WAIT_EVENT();
}
while (!(data_usb_buffer[buf_submitted].flags & USB_BUFFER_SUBMITTED)) {
id = data_usb_buffer[buf_submitted].id;
/* PRINTF("id: %02x\n", id); */
state.cmd_data_transfered += buffer_lengths[buf_submitted];
if (id == USB_BUFFER_ID_UNUSED) break;
data_usb_buffer[buf_submitted].id = USB_BUFFER_ID_UNUSED;
buf_submitted =NEXT_BUF(buf_submitted);
if (id & USB_MSC_DATA_DO_CALLBACK) {
if (state.data_cb) {
state.data_cb(&state);
}
}
if (id & USB_MSC_DATA_LAST) {
break;
}
}
if (id & USB_MSC_DATA_LAST) {
break;
}
}
if (state.cmd_data_submitted < cbw_buffer.dCBWDataTransferLength) {
submit_halt(BULK_OUT);
while(1) {
PROCESS_WAIT_EVENT();
if (ev == reset_event) goto reset_state;
if (ev == PROCESS_EVENT_POLL) {
USBBuffer *buffer = get_next_buffer(BULK_OUT, USB_BUFFER_ID_HALT);
if (buffer && (buffer->flags & USB_BUFFER_HALT)) break;
}
}
}
goto send_csw_state;
send_csw_state:
PRINTF("send_csw_state\n");
if (data_usb_buffer[PREV_BUF(buf_free)].id != USB_BUFFER_ID_CSW) {
send_csw();
}
submit_cbw_buffer();
while(1) {
if (ev == reset_event) goto reset_state;
PROCESS_WAIT_EVENT();
if (ev == PROCESS_EVENT_POLL) {
USBBuffer *buffer;
if ((buffer = get_next_buffer(BULK_IN, USB_BUFFER_ID_CSW))) {
goto receive_cbw_state;
}
}
}
goto receive_cbw_state;
PROCESS_END();
}
PROCESS_THREAD(usb_mass_bulk_process, ev , data)
{
PROCESS_BEGIN();
reset_event = process_alloc_event();
usb_msc_command_handler_init();
usb_setup();
usb_set_ep_event_process(BULK_IN, &usb_mass_bulk_request_process);
usb_set_ep_event_process(BULK_OUT, &usb_mass_bulk_request_process);
usb_set_global_event_process(process_current);
usb_register_request_handler(&mass_bulk_request_hook);
while(1) {
PROCESS_WAIT_EVENT();
if (ev == PROCESS_EVENT_EXIT) break;
if (ev == PROCESS_EVENT_POLL) {
unsigned int events = usb_get_global_events();
if (events) {
if (events & USB_EVENT_CONFIG) {
if (usb_get_current_configuration() != 0) {
PRINTF("Configured\n");
memset(data_usb_buffer, 0, sizeof(data_usb_buffer));
usb_setup_bulk_endpoint(BULK_IN);
usb_setup_bulk_endpoint(BULK_OUT);
process_start(&usb_mass_bulk_request_process,NULL);
} else {
process_exit(&usb_mass_bulk_request_process);
usb_disable_endpoint(BULK_IN);
usb_disable_endpoint(BULK_OUT);
}
}
if (events & USB_EVENT_RESET) {
PRINTF("RESET\n");
process_exit(&usb_mass_bulk_request_process);
}
}
}
}
PROCESS_END();
}
void
usb_msc_bulk_setup()
{
process_start(&usb_mass_bulk_process, NULL);
}