static void
handle_blit(uint8_t *data, unsigned int length)
{
int x;
int y;
struct BlitReport *blit;
uint8_t *p;
if (length < sizeof(struct BlitReport)) {
usb_error_stall();
return;
}
blit = (struct BlitReport*)data;
printf("Blit: (%d,%d) - (%d,%d)\n",blit->x1,blit->y1,blit->x2,blit->y2);
if (sizeof(struct BlitReport)
+ (((blit->x2-blit->x1) * (blit->y2-blit->y1) - 1)
* sizeof(blit->pixels[0])) > length) {
printf("Not enough blit data\n");
usb_error_stall();
return;
}
if (blit->x2 > SIZE_X || blit->x1 > blit->x2
|| blit->y2 > SIZE_Y || blit->y1 > blit->y2) {
printf("Illegal rect\n");
usb_error_stall();
return;
}
p = (uint8_t*)&blit->pixels;
for(y = blit->y1; y < blit->y2; y++) {
for(x = blit->x1; x < blit->x2; x++) {
ws2812_encode_rgb(ws_buffer + x + y * SIZE_X, p[0], p[1], p[2]);
p += 3;
}
}
usb_send_ctrl_status();
}
static void
get_string_descriptor()
{
#if OLD_STRING_DESCR
if(LOW_BYTE(usb_setup_buffer.wValue) == 0) {
usb_send_ctrl_response((const unsigned char *)string_languages->
lang_descr, string_languages->lang_descr->bLength);
} else {
const struct usb_st_string_descriptor *descriptor;
unsigned char l;
const struct usb_st_string_descriptor *const *table;
const struct usb_st_string_language_map *map;
if(LOW_BYTE(usb_setup_buffer.wValue) > string_languages->max_index) {
usb_error_stall();
return;
}
l = string_languages->num_lang;
map = string_languages->map;
table = map->descriptors; /* Use first table if language not found */
while(l > 0) {
if(map->lang_id == usb_setup_buffer.wIndex) {
table = map->descriptors;
break;
}
map++;
l--;
}
PRINTF("Lang id %04x = table %p\n", usb_setup_buffer.wIndex,
(void *)table);
descriptor = table[LOW_BYTE(usb_setup_buffer.wValue) - 1];
usb_send_ctrl_response((const unsigned char *)descriptor,
descriptor->bLength);
}
#else
const struct usb_st_string_descriptor *descriptor;
descriptor = (struct usb_st_string_descriptor *)
usb_class_get_string_descriptor(usb_setup_buffer.wIndex,
LOW_BYTE(usb_setup_buffer.wValue));
if(!descriptor) {
usb_error_stall();
return;
}
usb_send_ctrl_response((const unsigned char *)descriptor,
descriptor->bLength);
#endif
}
static void
get_interface()
{
PRINTF("get_interface\r\n");
if (usb_configuration_value == 0) usb_error_stall();
else {
usb_send_ctrl_response(&zero_byte,
sizeof(zero_byte));
}
}
PROCESS_THREAD(usb_process, ev , data)
{
PROCESS_BEGIN();
PRINTF("USB process started\r\n");
while(1) {
PROCESS_WAIT_EVENT();
if (ev == PROCESS_EVENT_EXIT) break;
if (ev == PROCESS_EVENT_POLL) {
unsigned int events = usb_arch_get_global_events();
if (events) {
if (events & USB_EVENT_RESET) {
submit_setup();
usb_configuration_value = 0;
notify_user(USB_EVENT_RESET);
}
if (events & USB_EVENT_SUSPEND) {
notify_user(USB_EVENT_SUSPEND);
}
if (events & USB_EVENT_RESUME) {
notify_user(USB_EVENT_RESUME);
}
}
events = usb_get_ep_events(0);
if (events) {
if ((events & USB_EP_EVENT_NOTIFICATION)
&& !(ctrl_buffer.flags & USB_BUFFER_SUBMITTED)) {
/* PRINTF("Endpoint 0\r\n"); */
if (ctrl_buffer.flags & USB_BUFFER_FAILED) {
/* Something went wrong with the buffer, just wait for a
new SETUP packet */
PRINTF("Discarded\r\n");
submit_setup();
} else if (ctrl_buffer.flags & USB_BUFFER_SETUP) {
struct USBRequestHandlerHook *hook = usb_request_handler_hooks;
PRINTF("Setup\r\n");
#if 0
{
unsigned int i;
for (i = 0; i< 8; i++) PRINTF(" %02x", ((unsigned char*)&usb_setup_buffer)[i]);
PRINTF("\r\n");
}
#endif
while(hook) {
const struct USBRequestHandler *handler = hook->handler;
/* Check if the handler matches the request */
if (((handler->request_type ^ usb_setup_buffer.bmRequestType)
& handler->request_type_mask) == 0
&& ((handler->request ^ usb_setup_buffer.bRequest)
& handler->request_mask) == 0) {
if (handler->handler_func()) break;
}
hook = hook->next;
}
if (!hook) {
/* No handler found */
usb_error_stall();
PRINTF("Unhandled setup: %02x %02x %04x %04x %04x\r\n",
usb_setup_buffer.bmRequestType, usb_setup_buffer.bRequest,
usb_setup_buffer.wValue, usb_setup_buffer.wIndex,
usb_setup_buffer.wLength);
}
/* Check if any handler stalled the pipe, if so prepare for
next setup */
if (error_stall) {
error_stall = 0;
submit_setup();
}
} else {
if (ctrl_buffer.id == IN_ID) {
/* Receive status stage */
PRINTF("Status OUT\r\n");
ctrl_buffer.flags = USB_BUFFER_NOTIFY;
ctrl_buffer.next = NULL;
ctrl_buffer.data = NULL;
ctrl_buffer.left = 0;
ctrl_buffer.id = STATUS_OUT_ID;
usb_submit_recv_buffer(0,&ctrl_buffer);
} else if (ctrl_buffer.id == STATUS_OUT_ID) {
PRINTF("Status OUT done\r\n");
submit_setup();
} else if (ctrl_buffer.id == STATUS_IN_ID) {
PRINTF("Status IN done\r\n");
if (usb_flags & USB_FLAG_ADDRESS_PENDING) {
while(usb_send_pending(0));
usb_arch_set_address(LOW_BYTE(usb_setup_buffer.wValue));
usb_flags &= ~USB_FLAG_ADDRESS_PENDING;
}
submit_setup();
} else if (ctrl_buffer.id == OUT_ID) {
PRINTF("OUT\r\n");
if (data_callback) {
data_callback(ctrl_data, ctrl_data_len- ctrl_buffer.left);
} else {
usb_send_ctrl_status();
}
}
}
}
}
}
}
PROCESS_END();
}
static unsigned int
handle_standard_requests()
{
switch(usb_setup_buffer.bmRequestType) {
case 0x80: /* standard device IN requests */
switch(usb_setup_buffer.bRequest) {
case GET_DESCRIPTOR:
switch (HIGH_BYTE(usb_setup_buffer.wValue)) {
case DEVICE:
get_device_descriptor();
break;
case CONFIGURATION:
get_configuration_descriptor();
break;
case STRING:
get_string_descriptor();
break;
default:
/* Unknown descriptor */
return 0;
}
break;
case GET_CONFIGURATION:
get_configuration();
break;
case GET_STATUS:
get_device_status();
break;
case GET_INTERFACE:
get_interface();
break;
default:
return 0;
}
break;
case 0x81: /* standard interface IN requests */
switch(usb_setup_buffer.bRequest) {
case GET_STATUS:
get_interface_status();
break;
#ifdef HID_ENABLED
case GET_DESCRIPTOR:
switch (USB_setup_buffer.wValue.byte.high) {
case REPORT:
get_report_descriptor();
break;
}
break;
#endif
default:
return 0;
}
break;
case 0x82: /* standard endpoint IN requests */
switch(usb_setup_buffer.bRequest) {
case GET_STATUS:
get_endpoint_status();
break;
default:
return 0;
}
break;
case 0x00: /* standard device OUT requests */
switch(usb_setup_buffer.bRequest) {
case SET_ADDRESS:
PRINTF("Address: %d\r\n", LOW_BYTE(usb_setup_buffer.wValue));
usb_flags |= USB_FLAG_ADDRESS_PENDING;
/* The actual setting of the address is done when the status packet
is sent. */
usb_send_ctrl_status();
break;
#if SETABLE_STRING_DESCRIPTORS > 0
case SET_DESCRIPTOR:
if (usb_setup_buffer.wValue.byte.high == STRING) {
set_string_descriptor();
} else {
return 0;
}
break;
#endif
case SET_CONFIGURATION:
if (set_configuration()) {
#if 0
config_msg.data.config = LOW_BYTE(usb_setup_buffer.wValue);
notify_user(&config_msg);
#endif
}
break;
default:
return 0;
}
break;
case 0x01: /* standard interface OUT requests */
switch(usb_setup_buffer.bRequest) {
case SET_INTERFACE:
/* Change interface here if we support more than one */
usb_send_ctrl_status();
break;
default:
return 0;
}
break;
case 0x02: /* standard endpoint OUT requests */
switch(usb_setup_buffer.bRequest) {
case SET_FEATURE:
case CLEAR_FEATURE:
if (usb_setup_buffer.wValue == ENDPOINT_HALT_FEATURE) {
usb_arch_halt_endpoint(usb_setup_buffer.wIndex, usb_setup_buffer.bRequest== SET_FEATURE);
usb_send_ctrl_status();
} else {
usb_error_stall();
}
break;
default:
return 0;
}
break;
#ifdef HID_ENABLED
case 0xa1: /* class specific interface IN request*/
switch(USB_setup_buffer.bRequest) {
case GET_HID_REPORT:
PRINTF("Get report\r\n");
send_ctrl_response((code u_int8_t*)&zero_byte,
sizeof(zero_byte));
break;
case GET_HID_IDLE:
PRINTF("Get idle\r\n");
send_ctrl_response((code u_int8_t*)&zero_byte,
sizeof(zero_byte));
break;
default:
return 0;
}
break;
case 0x21: /* class specific interface OUT request*/
switch(USB_setup_buffer.bRequest) {
case SET_HID_IDLE:
PRINTF("Set idle\r\n");
send_ctrl_status();
break;
default:
return 0;
}
break;
#endif
default:
return 0;
}
return 1;
}