Index: firmware/usbstack/usb_core.c =================================================================== --- firmware/usbstack/usb_core.c (revision 20662) +++ firmware/usbstack/usb_core.c (working copy) @@ -65,7 +65,7 @@ #define USB_PROT_BULK 0x50 /* bulk only */ static const struct usb_device_descriptor __attribute__((aligned(2))) - device_descriptor= + device_descriptor = { .bLength = sizeof(struct usb_device_descriptor), .bDescriptorType = USB_DT_DEVICE, @@ -88,7 +88,7 @@ } ; static struct usb_config_descriptor __attribute__((aligned(2))) - config_descriptor = + config_descriptor = { .bLength = sizeof(struct usb_config_descriptor), .bDescriptorType = USB_DT_CONFIG, @@ -97,12 +97,11 @@ .bConfigurationValue = 1, .iConfiguration = 0, .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER, - .bMaxPower = (USB_MAX_CURRENT+1) / 2, /* In 2mA units */ + .bMaxPower = (USB_MAX_CURRENT + 1) / 2, /* In 2mA units */ }; - static const struct usb_qualifier_descriptor __attribute__((aligned(2))) - qualifier_descriptor = + qualifier_descriptor = { .bLength = sizeof(struct usb_qualifier_descriptor), .bDescriptorType = USB_DT_DEVICE_QUALIFIER, @@ -115,7 +114,7 @@ }; static const struct usb_string_descriptor __attribute__((aligned(2))) - usb_string_iManufacturer = + usb_string_iManufacturer = { 24, USB_DT_STRING, @@ -123,7 +122,7 @@ }; static const struct usb_string_descriptor __attribute__((aligned(2))) - usb_string_iProduct = + usb_string_iProduct = { 42, USB_DT_STRING, @@ -133,7 +132,7 @@ }; static struct usb_string_descriptor __attribute__((aligned(2))) - usb_string_iSerial = + usb_string_iSerial = { 84, USB_DT_STRING, @@ -146,14 +145,14 @@ /* this is stringid #0: languages supported */ static const struct usb_string_descriptor __attribute__((aligned(2))) - lang_descriptor = + lang_descriptor = { 4, USB_DT_STRING, {0x0409} /* LANGID US English */ }; -static const struct usb_string_descriptor* const usb_strings[] = +static const struct usb_string_descriptor *const usb_strings[] = { &lang_descriptor, &usb_string_iManufacturer, @@ -168,7 +167,7 @@ static int usb_core_num_interfaces; typedef void (*completion_handler_t)(int ep,int dir, int status, int length); -typedef bool (*control_handler_t)(struct usb_ctrlrequest* req); +typedef bool (*control_handler_t)(struct usb_ctrlrequest *req); static struct { @@ -180,7 +179,8 @@ static struct usb_class_driver drivers[USB_NUM_DRIVERS] = { #ifdef USB_STORAGE - [USB_DRIVER_MASS_STORAGE] = { + [USB_DRIVER_MASS_STORAGE] = + { .enabled = false, .needs_exclusive_storage = true, .first_interface = 0, @@ -199,7 +199,8 @@ }, #endif #ifdef USB_SERIAL - [USB_DRIVER_SERIAL] = { + [USB_DRIVER_SERIAL] = + { .enabled = false, .needs_exclusive_storage = false, .first_interface = 0, @@ -218,7 +219,8 @@ }, #endif #ifdef USB_CHARGING_ONLY - [USB_DRIVER_CHARGING_ONLY] = { + [USB_DRIVER_CHARGING_ONLY] = + { .enabled = false, .needs_exclusive_storage = false, .first_interface = 0, @@ -238,7 +240,7 @@ #endif }; -static void usb_core_control_request_handler(struct usb_ctrlrequest* req); +static void usb_core_control_request_handler(struct usb_ctrlrequest *req); static unsigned char response_data[256] USB_DEVBSS_ATTR; @@ -258,16 +260,16 @@ into a utf-16 string of hex characters */ short* p = &usb_string_iSerial.wString[24]; uint32_t x; - int i,j; + int i, j; for (i = 0; i < 2; i++) { x = serial[i]; - for (j=0;j<8;j++) { + for (j = 0; j < 8; j++) { *p-- = hex[x & 0xf]; x >>= 4; } } - usb_string_iSerial.bLength=52; + usb_string_iSerial.bLength = 52; } #elif defined(HAVE_AS3514) static void set_serial_descriptor(void) @@ -301,38 +303,39 @@ *p++ = hex[(x >> 4) & 0xF]; *p++ = hex[(x >> 0) & 0xF]; } - usb_string_iSerial.bLength=84; + usb_string_iSerial.bLength = 84; } #elif (CONFIG_STORAGE & STORAGE_RAMDISK) /* This "serial number" isn't unique, but it should never actually appear in non-testing use */ static void set_serial_descriptor(void) { - short* p = &usb_string_iSerial.wString[1]; + short *p = &usb_string_iSerial.wString[1]; int i; for (i = 0; i < 16; i++) { - *p++ = hex[(2*i)&0xF]; - *p++ = hex[(2*i+1)&0xF]; + *p++ = hex[(2 * i) & 0xF]; + *p++ = hex[(2 * i + 1) & 0xF]; } - usb_string_iSerial.bLength=68; + usb_string_iSerial.bLength = 68; } #else #warning No proper set_serial_descriptor() implementation for this target static void set_serial_descriptor(void) { - short* p = &usb_string_iSerial.wString[1]; + short *p = &usb_string_iSerial.wString[1]; int i; for (i = 0; i < 16; i++) { - *p++ = hex[(2*i)&0xF]; - *p++ = hex[(2*i+1)&0xF]; + *p++ = hex[(2 * i) & 0xF]; + *p++ = hex[(2 * i + 1) & 0xF]; } - usb_string_iSerial.bLength=68; + usb_string_iSerial.bLength = 68; } #endif void usb_core_init(void) { int i; + if (initialized) return; @@ -341,8 +344,9 @@ /* class driver init functions should be safe to call even if the driver * won't be used. This simplifies other logic (i.e. we don't need to know * yet which drivers will be enabled */ - for(i=0;iendpoint; - switch(ep) { + switch (ep) + { case EP_CONTROL: - logf("ctrl handled %ld",current_tick); + logf("ctrl handled %ld", current_tick); usb_core_control_request_handler( - (struct usb_ctrlrequest*)event->data); + (struct usb_ctrlrequest *)event->data); break; default: - if(ep_data[ep].completion_handler[event->dir>>7] != NULL) - ep_data[ep].completion_handler[event->dir>>7](ep,event->dir, - event->status,event->length); + if (ep_data[ep].completion_handler[event->dir >> 7] != NULL) + { + ep_data[ep].completion_handler[event->dir >> 7](ep, event->dir, + event->status, event->length); + } break; } } -void usb_core_enable_driver(int driver,bool enabled) +void usb_core_enable_driver(int driver, bool enabled) { drivers[driver].enabled = enabled; } @@ -402,39 +412,40 @@ bool usb_core_any_exclusive_storage(void) { int i; - for(i=0;ibRequestType & 0x1f) { + switch(req->bRequestType & 0x1f) + { case 0: /* Device */ - switch (req->bRequest) { - case USB_REQ_GET_CONFIGURATION: { - logf("usb_core: GET_CONFIG"); - if (usb_state == ADDRESS) - response_data[0] = 0; - else - response_data[0] = 1; - if(usb_drv_send(EP_CONTROL, response_data, 1)!= 0) + switch (req->bRequest) + { + case USB_REQ_GET_CONFIGURATION: + { + logf("usb_core: GET_CONFIG"); + if (usb_state == ADDRESS) + response_data[0] = 0; + else + response_data[0] = 1; + if (usb_drv_send(EP_CONTROL, response_data, 1) != 0) + break; + usb_core_ack_control(req); break; - usb_core_ack_control(req); - break; - case USB_REQ_SET_CONFIGURATION: - logf("usb_core: SET_CONFIG"); - usb_drv_cancel_all_transfers(); - if (req->wValue) { - usb_state = CONFIGURED; - for(i=0;iwValue) + { + usb_state = CONFIGURED; + for (i = 0; i < USB_NUM_DRIVERS; i++) { - drivers[i].init_connection(); + if (drivers[i].enabled && + drivers[i].init_connection != NULL) + { + drivers[i].init_connection(); + } } } + else + { + usb_state = ADDRESS; + } + usb_core_ack_control(req); + break; } - else { + case USB_REQ_SET_ADDRESS: + { + unsigned char address = req->wValue; + logf("usb_core: SET_ADR %d", address); + if (usb_core_ack_control(req) != 0) + break; + usb_drv_cancel_all_transfers(); + usb_address = address; + usb_drv_set_address(usb_address); usb_state = ADDRESS; + break; } - usb_core_ack_control(req); - break; - } - case USB_REQ_SET_ADDRESS: { - unsigned char address = req->wValue; - logf("usb_core: SET_ADR %d", address); - if(usb_core_ack_control(req)!=0) - break; - usb_drv_cancel_all_transfers(); - usb_address = address; - usb_drv_set_address(usb_address); - usb_state = ADDRESS; - break; - } - case USB_REQ_GET_DESCRIPTOR: { - int index = req->wValue & 0xff; - int length = req->wLength; - int size; - const void* ptr = NULL; - logf("usb_core: GET_DESC %d", req->wValue >> 8); + case USB_REQ_GET_DESCRIPTOR: + { + int index = req->wValue & 0xff; + int length = req->wLength; + int size; + const void *ptr = NULL; - switch (req->wValue >> 8) { /* type */ - case USB_DT_DEVICE: - ptr = &device_descriptor; - size = sizeof(struct usb_device_descriptor); - break; + logf("usb_core: GET_DESC %d", req->wValue >> 8); - case USB_DT_OTHER_SPEED_CONFIG: - case USB_DT_CONFIG: { - int max_packet_size; + switch (req->wValue >> 8) /* type */ + { + case USB_DT_DEVICE: + ptr = &device_descriptor; + size = sizeof(struct usb_device_descriptor); + break; - if(req->wValue >> 8 == USB_DT_CONFIG) { - if(usb_drv_port_speed()) - max_packet_size=512; - else - max_packet_size=64; - config_descriptor.bDescriptorType=USB_DT_CONFIG; - } - else { - if(usb_drv_port_speed()) - max_packet_size=64; - else - max_packet_size=512; - config_descriptor.bDescriptorType = - USB_DT_OTHER_SPEED_CONFIG; - } - size = sizeof(struct usb_config_descriptor); + case USB_DT_OTHER_SPEED_CONFIG: + case USB_DT_CONFIG: + { + int max_packet_size; - for(i=0;iwValue >> 8 == USB_DT_CONFIG) + { + if (usb_drv_port_speed()) + max_packet_size = 512; + else + max_packet_size = 64; + config_descriptor.bDescriptorType = USB_DT_CONFIG; + } + else + { + if(usb_drv_port_speed()) + max_packet_size = 64; + else + max_packet_size = 512; + config_descriptor.bDescriptorType = + USB_DT_OTHER_SPEED_CONFIG; + } + size = sizeof(struct usb_config_descriptor); + + for (i = 0; i < USB_NUM_DRIVERS; i++) + { + if(drivers[i].enabled && + drivers[i].get_config_descriptor) + { + size+=drivers[i].get_config_descriptor( + &response_data[size], max_packet_size); + } + } + config_descriptor.bNumInterfaces = + usb_core_num_interfaces; + config_descriptor.wTotalLength = size; + memcpy(&response_data[0], &config_descriptor, + sizeof(struct usb_config_descriptor)); + + ptr = response_data; + break; + } + + case USB_DT_STRING: + logf("STRING %d", index); + if ((unsigned)index < (sizeof(usb_strings) / + sizeof(struct usb_string_descriptor*))) { - size+=drivers[i].get_config_descriptor( - &response_data[size], - max_packet_size); + size = usb_strings[index]->bLength; + ptr = usb_strings[index]; } - } - config_descriptor.bNumInterfaces = - usb_core_num_interfaces; - config_descriptor.wTotalLength = size; - memcpy(&response_data[0],&config_descriptor, - sizeof(struct usb_config_descriptor)); + else + { + logf("bad string id %d", index); + usb_drv_stall(EP_CONTROL, true,true); + } + break; - ptr = response_data; - break; + case USB_DT_DEVICE_QUALIFIER: + ptr = &qualifier_descriptor; + size = sizeof (struct usb_qualifier_descriptor); + break; + + default: + logf("bad desc %d", req->wValue >> 8); + usb_drv_stall(EP_CONTROL, true, true); + break; } - case USB_DT_STRING: - logf("STRING %d",index); - if ((unsigned)index < (sizeof(usb_strings)/ - sizeof(struct usb_string_descriptor*))) + if (ptr) + { + length = MIN(size, length); + + if (ptr != response_data) { - size = usb_strings[index]->bLength; - ptr = usb_strings[index]; + memcpy(response_data, ptr, length); } - else { - logf("bad string id %d", index); - usb_drv_stall(EP_CONTROL, true,true); - } - break; - case USB_DT_DEVICE_QUALIFIER: - ptr = &qualifier_descriptor; - size = sizeof (struct usb_qualifier_descriptor); - break; - - default: - logf("bad desc %d", req->wValue >> 8); - usb_drv_stall(EP_CONTROL, true,true); - break; - } - - if (ptr) { - length = MIN(size, length); - - if (ptr != response_data) { - memcpy(response_data, ptr, length); + if (usb_drv_send(EP_CONTROL, response_data, length) != 0) + break; } - - if(usb_drv_send(EP_CONTROL, response_data, length)!=0) - break; - } - usb_core_ack_control(req); - break; - } /* USB_REQ_GET_DESCRIPTOR */ + usb_core_ack_control(req); + break; + } /* USB_REQ_GET_DESCRIPTOR */ case USB_REQ_CLEAR_FEATURE: break; case USB_REQ_SET_FEATURE: - if(req->wValue == 2) { /* TEST_MODE */ - int mode=req->wIndex>>8; + if (req->wValue == 2) /* TEST_MODE */ + { + int mode = req->wIndex >> 8; usb_core_ack_control(req); usb_drv_set_test_mode(mode); } break; case USB_REQ_GET_STATUS: - response_data[0]= 0; - response_data[1]= 0; - if(usb_drv_send(EP_CONTROL, response_data, 2)!=0) + response_data[0] = 0; + response_data[1] = 0; + if (usb_drv_send(EP_CONTROL, response_data, 2) != 0) break; usb_core_ack_control(req); break; @@ -662,7 +695,8 @@ } break; case 1: /* Interface */ - switch (req->bRequest) { + switch (req->bRequest) + { case USB_REQ_SET_INTERFACE: logf("usb_core: SET_INTERFACE"); usb_core_ack_control(req); @@ -671,7 +705,7 @@ case USB_REQ_GET_INTERFACE: logf("usb_core: GET_INTERFACE"); response_data[0] = 0; - if(usb_drv_send(EP_CONTROL, response_data, 1)!=0) + if (usb_drv_send(EP_CONTROL, response_data, 1) != 0) break; usb_core_ack_control(req); break; @@ -680,70 +714,79 @@ case USB_REQ_SET_FEATURE: break; case USB_REQ_GET_STATUS: - response_data[0]= 0; - response_data[1]= 0; - if(usb_drv_send(EP_CONTROL, response_data, 2)!=0) + response_data[0] = 0; + response_data[1] = 0; + if (usb_drv_send(EP_CONTROL, response_data, 2) != 0) break; usb_core_ack_control(req); break; - default: { - bool handled=false; - for(i=0;iwIndex) && - drivers[i].last_interface > (req->wIndex)) + default: + { + bool handled = false; + for (i = 0; i < USB_NUM_DRIVERS; i++) { - handled = drivers[i].control_request(req); + if(drivers[i].enabled && + drivers[i].control_request && + drivers[i].first_interface <= (req->wIndex) && + drivers[i].last_interface > (req->wIndex)) + { + handled = drivers[i].control_request(req); + } } + if (!handled) + { + /* nope. flag error */ + logf("usb bad req %d", req->bRequest); + usb_drv_stall(EP_CONTROL, true,true); + usb_core_ack_control(req); + } + break; } - if(!handled) { - /* nope. flag error */ - logf("usb bad req %d", req->bRequest); - usb_drv_stall(EP_CONTROL, true,true); - usb_core_ack_control(req); - } - break; - } } break; case 2: /* Endpoint */ - switch (req->bRequest) { + switch (req->bRequest) + { case USB_REQ_CLEAR_FEATURE: - if (req->wValue == 0 ) /* ENDPOINT_HALT */ + if (req->wValue == 0) /* ENDPOINT_HALT */ + { usb_drv_stall(req->wIndex & 0xf, false, - (req->wIndex & 0x80) !=0); + (req->wIndex & 0x80) != 0); + } usb_core_ack_control(req); break; case USB_REQ_SET_FEATURE: - if (req->wValue == 0 ) /* ENDPOINT_HALT */ + if (req->wValue == 0) /* ENDPOINT_HALT */ usb_drv_stall(req->wIndex & 0xf, true, - (req->wIndex & 0x80) !=0); + (req->wIndex & 0x80) != 0); usb_core_ack_control(req); break; case USB_REQ_GET_STATUS: - response_data[0]= 0; - response_data[1]= 0; - logf("usb_core: GET_STATUS"); - if(req->wIndex>0) - response_data[0] = usb_drv_stalled(req->wIndex&0xf, - (req->wIndex&0x80)!=0); - if(usb_drv_send(EP_CONTROL, response_data, 2)!=0) + response_data[0] = 0; + response_data[1] = 0; + logf("usb_core: GET_STATUS"); + if (req->wIndex > 0) + response_data[0] = usb_drv_stalled(req->wIndex & 0xf, + (req->wIndex & 0x80) != 0); + if (usb_drv_send(EP_CONTROL, response_data, 2) != 0) break; usb_core_ack_control(req); break; - default: { - bool handled=false; - if(ep_data[req->wIndex & 0xf].control_handler[0] != NULL) - handled = ep_data[req->wIndex & 0xf].control_handler[0](req); - if(!handled) { - /* nope. flag error */ - logf("usb bad req %d", req->bRequest); - usb_drv_stall(EP_CONTROL, true,true); - usb_core_ack_control(req); + default: + { + bool handled = false; + + if (ep_data[req->wIndex & 0xf].control_handler[0] != NULL) + handled = ep_data[req->wIndex & 0xf].control_handler[0](req); + if (!handled) + { + /* nope. flag error */ + logf("usb bad req %d", req->bRequest); + usb_drv_stall(EP_CONTROL, true, true); + usb_core_ack_control(req); + } + break; } - break; - } } } logf("control handled"); @@ -759,17 +802,18 @@ /* called by usb_drv_transfer_completed() */ void usb_core_transfer_complete(int endpoint, int dir, int status,int length) { - switch (endpoint) { + switch (endpoint) + { case EP_CONTROL: /* already handled */ break; default: - ep_data[endpoint].completion_event.endpoint=endpoint; - ep_data[endpoint].completion_event.dir=dir; - ep_data[endpoint].completion_event.data=0; - ep_data[endpoint].completion_event.status=status; - ep_data[endpoint].completion_event.length=length; + ep_data[endpoint].completion_event.endpoint = endpoint; + ep_data[endpoint].completion_event.dir = dir; + ep_data[endpoint].completion_event.data = 0; + ep_data[endpoint].completion_event.status = status; + ep_data[endpoint].completion_event.length = length; /* All other endoints. Let the thread deal with it */ usb_signal_transfer_completion(&ep_data[endpoint].completion_event); break; @@ -777,18 +821,18 @@ } /* called by usb_drv_int() */ -void usb_core_control_request(struct usb_ctrlrequest* req) +void usb_core_control_request(struct usb_ctrlrequest *req) { - ep_data[0].completion_event.endpoint=0; - ep_data[0].completion_event.dir=0; - ep_data[0].completion_event.data=(void *)req; - ep_data[0].completion_event.status=0; - ep_data[0].completion_event.length=0; - logf("ctrl received %ld",current_tick); + ep_data[0].completion_event.endpoint = 0; + ep_data[0].completion_event.dir = 0; + ep_data[0].completion_event.data = (void *)req; + ep_data[0].completion_event.status = 0; + ep_data[0].completion_event.length = 0; + logf("ctrl received %ld", current_tick); usb_signal_transfer_completion(&ep_data[0].completion_event); } -int usb_core_ack_control(struct usb_ctrlrequest* req) +int usb_core_ack_control(struct usb_ctrlrequest *req) { if (req->bRequestType & 0x80) return usb_drv_recv(EP_CONTROL, NULL, 0); Index: firmware/usbstack/usb_charging_only.c =================================================================== --- firmware/usbstack/usb_charging_only.c (revision 20662) +++ firmware/usbstack/usb_charging_only.c (working copy) @@ -32,7 +32,7 @@ /* charging_only interface */ static struct usb_interface_descriptor __attribute__((aligned(2))) - interface_descriptor = + interface_descriptor = { .bLength = sizeof(struct usb_interface_descriptor), .bDescriptorType = USB_DT_INTERFACE, @@ -45,32 +45,34 @@ .iInterface = 0 }; - static int usb_interface; int usb_charging_only_request_endpoints(struct usb_class_driver *drv) { (void) drv; + return 0; } int usb_charging_only_set_first_interface(int interface) { usb_interface = interface; + return interface + 1; } -int usb_charging_only_get_config_descriptor(unsigned char *dest,int max_packet_size) +int usb_charging_only_get_config_descriptor(unsigned char *dest, + int max_packet_size) { (void)max_packet_size; unsigned char *orig_dest = dest; - interface_descriptor.bInterfaceNumber=usb_interface; - memcpy(dest,&interface_descriptor,sizeof(struct usb_interface_descriptor)); + interface_descriptor.bInterfaceNumber = usb_interface; + memcpy(dest, &interface_descriptor, sizeof(struct usb_interface_descriptor)); - dest+=sizeof(struct usb_interface_descriptor); + dest += sizeof(struct usb_interface_descriptor); - return (dest-orig_dest); + return (dest - orig_dest); } #endif /*USB_CHARGING_ONLY*/ Index: firmware/usbstack/usb_serial.c =================================================================== --- firmware/usbstack/usb_serial.c (revision 20662) +++ firmware/usbstack/usb_serial.c (working copy) @@ -24,7 +24,6 @@ #include "usb_drv.h" #include "kernel.h" #include "usb_serial.h" - //#define LOGF_ENABLE #include "logf.h" @@ -32,7 +31,7 @@ /* serial interface */ static struct usb_interface_descriptor __attribute__((aligned(2))) - interface_descriptor = + interface_descriptor = { .bLength = sizeof(struct usb_interface_descriptor), .bDescriptorType = USB_DT_INTERFACE, @@ -46,7 +45,8 @@ }; -static struct usb_endpoint_descriptor __attribute__((aligned(2))) endpoint_descriptor = +static struct usb_endpoint_descriptor __attribute__((aligned(2))) + endpoint_descriptor = { .bLength = sizeof(struct usb_endpoint_descriptor), .bDescriptorType = USB_DT_ENDPOINT, @@ -77,13 +77,12 @@ int usb_serial_request_endpoints(struct usb_class_driver *drv) { ep_in = usb_core_request_endpoint(USB_DIR_IN, drv); - if (ep_in < 0) return -1; - - ep_out = usb_core_request_endpoint(USB_DIR_OUT, drv); - if (ep_out < 0) { + ep_out = usb_core_request_endpoint(USB_DIR_OUT, drv); + if (ep_out < 0) + { usb_core_release_endpoint(ep_in); return -1; } @@ -94,27 +93,27 @@ int usb_serial_set_first_interface(int interface) { usb_interface = interface; + return interface + 1; } - -int usb_serial_get_config_descriptor(unsigned char *dest,int max_packet_size) +int usb_serial_get_config_descriptor(unsigned char *dest, int max_packet_size) { unsigned char *orig_dest = dest; - endpoint_descriptor.wMaxPacketSize=max_packet_size; - interface_descriptor.bInterfaceNumber=usb_interface; + endpoint_descriptor.wMaxPacketSize = max_packet_size; + interface_descriptor.bInterfaceNumber = usb_interface; - memcpy(dest,&interface_descriptor,sizeof(struct usb_interface_descriptor)); - dest+=sizeof(struct usb_interface_descriptor); + memcpy(dest, &interface_descriptor, sizeof(struct usb_interface_descriptor)); + dest += sizeof(struct usb_interface_descriptor); endpoint_descriptor.bEndpointAddress = ep_in; - memcpy(dest,&endpoint_descriptor,sizeof(struct usb_endpoint_descriptor)); - dest+=sizeof(struct usb_endpoint_descriptor); + memcpy(dest, &endpoint_descriptor, sizeof(struct usb_endpoint_descriptor)); + dest += sizeof(struct usb_endpoint_descriptor); endpoint_descriptor.bEndpointAddress = ep_out; - memcpy(dest,&endpoint_descriptor,sizeof(struct usb_endpoint_descriptor)); - dest+=sizeof(struct usb_endpoint_descriptor); + memcpy(dest, &endpoint_descriptor, sizeof(struct usb_endpoint_descriptor)); + dest += sizeof(struct usb_endpoint_descriptor); return (dest - orig_dest); } @@ -123,7 +122,8 @@ bool usb_serial_control_request(struct usb_ctrlrequest* req) { bool handled = false; - switch (req->bRequest) { + switch (req->bRequest) + { default: logf("serial: unhandeld req %d", req->bRequest); } @@ -133,15 +133,15 @@ void usb_serial_init_connection(void) { /* prime rx endpoint */ - usb_drv_recv(ep_out, receive_buffer, sizeof receive_buffer); + usb_drv_recv(ep_out, receive_buffer, sizeof(receive_buffer)); /* we come here too after a bus reset, so reset some data */ buffer_transitlength = 0; - if(buffer_length>0) + if (buffer_length > 0) { sendout(); } - active=true; + active = true; } /* called by usb_code_init() */ @@ -161,56 +161,55 @@ static void sendout(void) { - if(buffer_start+buffer_length >= BUFFER_SIZE) + if (buffer_start + buffer_length >= BUFFER_SIZE) { /* Buffer wraps. Only send the first part */ - buffer_transitlength=BUFFER_SIZE - buffer_start; + buffer_transitlength = BUFFER_SIZE - buffer_start; } else { /* Send everything */ - buffer_transitlength=buffer_length; + buffer_transitlength = buffer_length; } - if(buffer_transitlength>0) + if (buffer_transitlength > 0) { - buffer_length-=buffer_transitlength; + buffer_length -= buffer_transitlength; usb_drv_send_nonblocking(ep_in, &send_buffer[buffer_start], buffer_transitlength); } } -void usb_serial_send(unsigned char *data,int length) +void usb_serial_send(unsigned char *data, int length) { if(!active) return; - if(length<=0) + if(length <= 0) return; int freestart=(buffer_start+buffer_length+buffer_transitlength)%BUFFER_SIZE; - if(buffer_start+buffer_transitlength+buffer_length >= BUFFER_SIZE) - { + if (buffer_start+buffer_transitlength+buffer_length >= BUFFER_SIZE) + { /* current buffer wraps, so new data can't */ int available_space = BUFFER_SIZE - buffer_length - buffer_transitlength; - length=MIN(length,available_space); - memcpy(&send_buffer[freestart], - data,length); - buffer_length+=length; + length = MIN(length, available_space); + memcpy(&send_buffer[freestart], data,length); + buffer_length += length; } else { /* current buffer doesn't wrap, so new data might */ - int available_end_space = (BUFFER_SIZE - (buffer_start+buffer_length+buffer_transitlength)); - int first_chunk = MIN(length,available_end_space); - memcpy(&send_buffer[freestart],data,first_chunk); - length-=first_chunk; - buffer_length+=first_chunk; - if(length>0) + int available_end_space = (BUFFER_SIZE - (buffer_start+buffer_length + buffer_transitlength)); + int first_chunk = MIN(length, available_end_space); + memcpy(&send_buffer[freestart], data, first_chunk); + length -= first_chunk; + buffer_length += first_chunk; + if(length > 0) { /* wrap */ - memcpy(&send_buffer[0],&data[first_chunk],MIN(length,buffer_start)); - buffer_length+=MIN(length,buffer_start); + memcpy(&send_buffer[0], &data[first_chunk], MIN(length, buffer_start)); + buffer_length += MIN(length, buffer_start); } } - if(buffer_transitlength>0) + if(buffer_transitlength > 0) { /* Do nothing. The transfer completion handler will pick it up */ } @@ -224,7 +223,9 @@ void usb_serial_transfer_complete(int ep,int dir, int status, int length) { (void)ep; - switch (dir) { + + switch (dir) + { case USB_DIR_OUT: logf("serial: %s", receive_buffer); /* Data received. TODO : Do something with it ? */ @@ -235,23 +236,20 @@ case USB_DIR_IN: /* Data sent out. Update circular buffer */ - if(status == 0) + if (status == 0) { - if(length!=buffer_transitlength) + if (length != buffer_transitlength) { /* do something? */ } - buffer_start = (buffer_start + buffer_transitlength)%BUFFER_SIZE; + buffer_start = (buffer_start + buffer_transitlength) % BUFFER_SIZE; buffer_transitlength = 0; } - if(buffer_length>0) - { + if(buffer_length > 0) sendout(); - } break; } } - #endif /*USB_SERIAL*/ Index: firmware/usbstack/usb_storage.c =================================================================== --- firmware/usbstack/usb_storage.c (revision 20662) +++ firmware/usbstack/usb_storage.c (working copy) @@ -57,8 +57,8 @@ #define USB_BULK_RESET_REQUEST 0xff #define USB_BULK_GET_MAX_LUN 0xfe -#define DIRECT_ACCESS_DEVICE 0x00 /* disks */ -#define DEVICE_REMOVABLE 0x80 +#define DIRECT_ACCESS_DEVICE 0x00 /* disks */ +#define DEVICE_REMOVABLE 0x80 #define CBW_SIGNATURE 0x43425355 #define CSW_SIGNATURE 0x53425355 @@ -102,7 +102,7 @@ #define USB_PROT_BULK 0x50 /* bulk only */ static struct usb_interface_descriptor __attribute__((aligned(2))) - interface_descriptor = + interface_descriptor = { .bLength = sizeof(struct usb_interface_descriptor), .bDescriptorType = USB_DT_INTERFACE, @@ -116,7 +116,7 @@ }; static struct usb_endpoint_descriptor __attribute__((aligned(2))) - endpoint_descriptor = + endpoint_descriptor = { .bLength = sizeof(struct usb_endpoint_descriptor), .bDescriptorType = USB_DT_ENDPOINT, @@ -126,11 +126,12 @@ .bInterval = 0 }; -struct inquiry_data { +struct inquiry_data +{ unsigned char DeviceType; unsigned char DeviceTypeModifier; unsigned char Versions; - unsigned char Format; + unsigned char Format; unsigned char AdditionalLength; unsigned char Reserved[2]; unsigned char Capability; @@ -139,14 +140,16 @@ unsigned char ProductRevisionLevel[4]; } __attribute__ ((packed)); -struct report_lun_data { +struct report_lun_data +{ unsigned int lun_list_length; unsigned int reserved1; // TODO this should be cleaned up with the VOLUMES vs DRIVES mess unsigned char luns[NUM_VOLUMES][8]; } __attribute__ ((packed)); -struct sense_data { +struct sense_data +{ unsigned char ResponseCode; unsigned char Obsolete; unsigned char fei_sensekey; @@ -160,20 +163,23 @@ unsigned short SenseKeySpecific; } __attribute__ ((packed)); -struct mode_sense_bdesc_longlba { +struct mode_sense_bdesc_longlba +{ unsigned char num_blocks[8]; unsigned char reserved[4]; unsigned char block_size[4]; } __attribute__ ((packed)); -struct mode_sense_bdesc_shortlba { +struct mode_sense_bdesc_shortlba +{ unsigned char density_code; unsigned char num_blocks[3]; unsigned char reserved; unsigned char block_size[3]; } __attribute__ ((packed)); -struct mode_sense_data_10 { +struct mode_sense_data_10 +{ unsigned short mode_data_length; unsigned char medium_type; unsigned char device_specific; @@ -183,7 +189,8 @@ struct mode_sense_bdesc_longlba block_descriptor; } __attribute__ ((packed)); -struct mode_sense_data_6 { +struct mode_sense_data_6 +{ unsigned char mode_data_length; unsigned char medium_type; unsigned char device_specific; @@ -191,7 +198,8 @@ struct mode_sense_bdesc_shortlba block_descriptor; } __attribute__ ((packed)); -struct command_block_wrapper { +struct command_block_wrapper +{ unsigned int signature; unsigned int tag; unsigned int data_transfer_length; @@ -201,26 +209,30 @@ unsigned char command_block[16]; } __attribute__ ((packed)); -struct command_status_wrapper { +struct command_status_wrapper +{ unsigned int signature; unsigned int tag; unsigned int data_residue; unsigned char status; } __attribute__ ((packed)); -struct capacity { +struct capacity +{ unsigned int block_count; unsigned int block_size; } __attribute__ ((packed)); -struct format_capacity { +struct format_capacity +{ unsigned int following_length; unsigned int block_count; unsigned int block_size; } __attribute__ ((packed)); -static union { +static union +{ unsigned char* transfer_buffer; struct inquiry_data* inquiry; struct capacity* capacity_data; @@ -233,7 +245,8 @@ char *max_lun; } tb; -static struct { +static struct +{ unsigned int sector; unsigned int count; unsigned int orig_count; @@ -245,7 +258,8 @@ unsigned int last_result; } cur_cmd; -static struct { +static struct +{ unsigned char sense_key; unsigned char information; unsigned char asc; @@ -254,10 +268,10 @@ static void handle_scsi(struct command_block_wrapper* cbw); static void send_csw(int status); -static void send_command_result(void *data,int size); +static void send_command_result(void *data, int size); static void send_command_failed_result(void); -static void send_block_data(void *data,int size); -static void receive_block_data(void *data,int size); +static void send_block_data(void *data, int size); +static void receive_block_data(void *data, int size); static void fill_inquiry(IF_MV_NONVOID(int lun)); static void send_and_read_next(void); static bool ejected[NUM_VOLUMES]; @@ -270,7 +284,8 @@ static unsigned char* ramdisk_buffer; #endif -static enum { +static enum +{ WAITING_FOR_COMMAND, SENDING_BLOCKS, SENDING_RESULT, @@ -302,40 +317,48 @@ return true; #else unsigned char sector[512]; - return storage_read_sectors(volume,0,1,sector) == 0; + + return storage_read_sectors(volume, 0, 1, sector) == 0; #endif } void usb_storage_try_release_storage(void) { - /* Check if there is a connected drive left. If not, + /* Check if there is a connected drive left. If not, release excusive access */ - bool canrelease=true; + bool canrelease = true; int i; - for(i=0;isignature) == CBW_SIGNATURE){ + if (letoh32(cbw->signature) == CBW_SIGNATURE) + { handle_scsi(cbw); } - else { - usb_drv_stall(ep_in, true,true); - usb_drv_stall(ep_out, true,false); + else + { + usb_drv_stall(ep_in, true, true); + usb_drv_stall(ep_out, true, false); } break; case SENDING_CSW: - if(dir==USB_DIR_OUT) { + if (dir == USB_DIR_OUT) + { logf("OUT received in SENDING_CSW"); } //logf("csw sent, now go back to idle"); state = WAITING_FOR_COMMAND; #if 0 - if(cur_cmd.cur_cmd == SCSI_WRITE_10) + if (cur_cmd.cur_cmd == SCSI_WRITE_10) { - queue_broadcast(SYS_USB_WRITE_DATA, (cur_cmd.lun<<16)+cur_cmd.orig_count); + queue_broadcast(SYS_USB_WRITE_DATA, (cur_cmd.lun << 16) + cur_cmd.orig_count); } - else if(cur_cmd.cur_cmd == SCSI_READ_10) + else if (cur_cmd.cur_cmd == SCSI_READ_10) { - queue_broadcast(SYS_USB_READ_DATA, (cur_cmd.lun<<16)+cur_cmd.orig_count); + queue_broadcast(SYS_USB_READ_DATA, (cur_cmd.lun << 16) + cur_cmd.orig_count); } #endif usb_drv_recv(ep_out, tb.transfer_buffer, 1024); break; case SENDING_RESULT: - if(dir==USB_DIR_OUT) { + if (dir == USB_DIR_OUT) + { logf("OUT received in SENDING"); } - if(status==0) { + if (status == 0) + { //logf("data sent, now send csw"); send_csw(UMS_STATUS_GOOD); } - else { - logf("Transfer failed %X",status); + else + { + logf("Transfer failed %X", status); send_csw(UMS_STATUS_FAIL); /* TODO fill in cur_sense_data */ - cur_sense_data.sense_key=0; - cur_sense_data.information=0; - cur_sense_data.asc=0; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = 0; + cur_sense_data.information = 0; + cur_sense_data.asc = 0; + cur_sense_data.ascq = 0; } break; case SENDING_FAILED_RESULT: - if(dir==USB_DIR_OUT) { + if (dir == USB_DIR_OUT) + { logf("OUT received in SENDING"); } send_csw(UMS_STATUS_FAIL); break; case SENDING_BLOCKS: - if(dir==USB_DIR_OUT) { + if (dir == USB_DIR_OUT) + { logf("OUT received in SENDING"); } - if(status==0) { - if(cur_cmd.count==0) { + if (status == 0) + { + if (cur_cmd.count == 0) + { //logf("data sent, now send csw"); send_csw(UMS_STATUS_GOOD); } - else { + else + { send_and_read_next(); } } - else { - logf("Transfer failed %X",status); + else + { + logf("Transfer failed %X", status); send_csw(UMS_STATUS_FAIL); /* TODO fill in cur_sense_data */ - cur_sense_data.sense_key=0; - cur_sense_data.information=0; - cur_sense_data.asc=0; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = 0; + cur_sense_data.information = 0; + cur_sense_data.asc = 0; + cur_sense_data.ascq = 0; } break; } @@ -600,20 +641,21 @@ { bool handled = false; - - switch (req->bRequest) { - case USB_BULK_GET_MAX_LUN: { + switch (req->bRequest) + { + case USB_BULK_GET_MAX_LUN: + { #ifdef ONLY_EXPOSE_CARD_SLOT - *tb.max_lun = 0; + *tb.max_lun = 0; #else - *tb.max_lun = NUM_VOLUMES - 1; + *tb.max_lun = NUM_VOLUMES - 1; #endif - logf("ums: getmaxlun"); - usb_drv_send(EP_CONTROL, tb.max_lun, 1); - usb_drv_recv(EP_CONTROL, NULL, 0); /* ack */ - handled = true; - break; - } + logf("ums: getmaxlun"); + usb_drv_send(EP_CONTROL, tb.max_lun, 1); + usb_drv_recv(EP_CONTROL, NULL, 0); /* ack */ + handled = true; + break; + } case USB_BULK_RESET_REQUEST: logf("ums: bulk reset"); @@ -625,7 +667,7 @@ usb_drv_reset_endpoint(ep_in, false); usb_drv_reset_endpoint(ep_out, true); #endif - + usb_drv_send(EP_CONTROL, NULL, 0); /* ack */ handled = true; break; @@ -636,36 +678,36 @@ static void send_and_read_next(void) { - if(cur_cmd.last_result!=0) { + if (cur_cmd.last_result != 0) + { /* The last read failed. */ send_csw(UMS_STATUS_FAIL); - cur_sense_data.sense_key=SENSE_MEDIUM_ERROR; - cur_sense_data.asc=ASC_READ_ERROR; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = SENSE_MEDIUM_ERROR; + cur_sense_data.asc = ASC_READ_ERROR; + cur_sense_data.ascq = 0; return; } send_block_data(cur_cmd.data[cur_cmd.data_select], - MIN(BUFFER_SIZE,cur_cmd.count*SECTOR_SIZE)); + MIN(BUFFER_SIZE, cur_cmd.count * SECTOR_SIZE)); /* Switch buffers for the next one */ - cur_cmd.data_select=!cur_cmd.data_select; + cur_cmd.data_select =! cur_cmd.data_select; cur_cmd.sector+=(BUFFER_SIZE/SECTOR_SIZE); cur_cmd.count-=MIN(cur_cmd.count,BUFFER_SIZE/SECTOR_SIZE); - if(cur_cmd.count!=0){ + if(cur_cmd.count != 0) + { /* already read the next bit, so we can send it out immediately when the * current transfer completes. */ #ifdef USB_USE_RAMDISK memcpy(cur_cmd.data[cur_cmd.data_select], - ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE, - MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count)*SECTOR_SIZE); + ramdisk_buffer + cur_cmd.sector * SECTOR_SIZE, + MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count) * SECTOR_SIZE); #else - cur_cmd.last_result = storage_read_sectors(cur_cmd.lun, - cur_cmd.sector, - MIN(BUFFER_SIZE/SECTOR_SIZE, - cur_cmd.count), - cur_cmd.data[cur_cmd.data_select]); + cur_cmd.last_result = storage_read_sectors(cur_cmd.lun, cur_cmd.sector, + MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count), + cur_cmd.data[cur_cmd.data_select]); #endif } } @@ -680,29 +722,28 @@ unsigned int length = cbw->data_transfer_length; unsigned int block_size = 0; unsigned int block_count = 0; - bool lun_present=true; + bool lun_present = true; #ifdef ONLY_EXPOSE_CARD_SLOT - unsigned char lun = cbw->lun+1; + unsigned char lun = cbw->lun + 1; #else unsigned char lun = cbw->lun; #endif unsigned int block_size_mult = 1; - storage_get_info(lun,&info); + storage_get_info(lun, &info); #ifdef USB_USE_RAMDISK block_size = SECTOR_SIZE; block_count = RAMDISK_SIZE; #else - block_size=info.sector_size; - block_count=info.num_sectors; + block_size = info.sector_size; + block_count = info.num_sectors; #endif #ifdef HAVE_HOTSWAP - if(storage_removable(lun) && !storage_present(lun)) { + if (storage_removable(lun) && !storage_present(lun)) ejected[lun] = true; - } #endif - if(ejected[lun]) + if (ejected[lun]) lun_present = false; #ifdef MAX_LOG_SECTOR_SIZE @@ -713,195 +754,210 @@ cur_cmd.lun = lun; cur_cmd.cur_cmd = cbw->command_block[0]; - switch (cbw->command_block[0]) { + switch (cbw->command_block[0]) + { case SCSI_TEST_UNIT_READY: - logf("scsi test_unit_ready %d",lun); - if(!usb_exclusive_storage()) { + logf("scsi test_unit_ready %d", lun); + if (!usb_exclusive_storage()) + { send_csw(UMS_STATUS_FAIL); - cur_sense_data.sense_key=SENSE_NOT_READY; - cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = SENSE_NOT_READY; + cur_sense_data.asc = ASC_MEDIUM_NOT_PRESENT; + cur_sense_data.ascq = 0; break; } - if(lun_present) { + if (lun_present) + { send_csw(UMS_STATUS_GOOD); } - else { + else + { send_csw(UMS_STATUS_FAIL); - cur_sense_data.sense_key=SENSE_NOT_READY; - cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = SENSE_NOT_READY; + cur_sense_data.asc = ASC_MEDIUM_NOT_PRESENT; + cur_sense_data.ascq = 0; } break; - case SCSI_REPORT_LUNS: { - logf("scsi report luns %d",lun); - int allocation_length=0; - int i; - allocation_length|=(cbw->command_block[6]<<24); - allocation_length|=(cbw->command_block[7]<<16); - allocation_length|=(cbw->command_block[8]<<8); - allocation_length|=(cbw->command_block[9]); - memset(tb.lun_data,0,sizeof(struct report_lun_data)); - tb.lun_data->lun_list_length=htobe32(8*NUM_VOLUMES); - for(i=0;icommand_block[6] << 24); + allocation_length |= (cbw->command_block[7] << 16); + allocation_length |= (cbw->command_block[8] << 8); + allocation_length |= (cbw->command_block[9]); + memset(tb.lun_data, 0, sizeof(struct report_lun_data)); + tb.lun_data->lun_list_length = htobe32(8 * NUM_VOLUMES); + for(i = 0; i < NUM_VOLUMES; i++) + { #ifdef HAVE_HOTSWAP - if(storage_removable(i)) - tb.lun_data->luns[i][1]=1; - else + if (storage_removable(i)) + tb.lun_data->luns[i][1] = 1; + else #endif - tb.lun_data->luns[i][1]=0; + tb.lun_data->luns[i][1] = 0; + } + send_command_result(tb.lun_data, + MIN(sizeof(struct report_lun_data), length)); + break; } - send_command_result(tb.lun_data, - MIN(sizeof(struct report_lun_data), length)); - break; - } case SCSI_INQUIRY: - logf("scsi inquiry %d",lun); + logf("scsi inquiry %d", lun); fill_inquiry(IF_MV(lun)); length = MIN(length, cbw->command_block[4]); send_command_result(tb.inquiry, - MIN(sizeof(struct inquiry_data), length)); + MIN(sizeof(struct inquiry_data), length)); break; - case SCSI_REQUEST_SENSE: { - tb.sense_data->ResponseCode=0x70;/*current error*/ - tb.sense_data->Obsolete=0; - tb.sense_data->fei_sensekey=cur_sense_data.sense_key&0x0f; - tb.sense_data->Information=cur_sense_data.information; - tb.sense_data->AdditionalSenseLength=10; - tb.sense_data->CommandSpecificInformation=0; - tb.sense_data->AdditionalSenseCode=cur_sense_data.asc; - tb.sense_data->AdditionalSenseCodeQualifier=cur_sense_data.ascq; - tb.sense_data->FieldReplaceableUnitCode=0; - tb.sense_data->SKSV=0; - tb.sense_data->SenseKeySpecific=0; - logf("scsi request_sense %d",lun); - send_command_result(tb.sense_data, sizeof(struct sense_data)); - break; - } - - case SCSI_MODE_SENSE_10: { - if(! lun_present) { - send_command_failed_result(); - cur_sense_data.sense_key=SENSE_NOT_READY; - cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; - cur_sense_data.ascq=0; + case SCSI_REQUEST_SENSE: + { + tb.sense_data->ResponseCode = 0x70;/*current error*/ + tb.sense_data->Obsolete = 0; + tb.sense_data->fei_sensekey = cur_sense_data.sense_key & 0x0f; + tb.sense_data->Information = cur_sense_data.information; + tb.sense_data->AdditionalSenseLength = 10; + tb.sense_data->CommandSpecificInformation = 0; + tb.sense_data->AdditionalSenseCode = cur_sense_data.asc; + tb.sense_data->AdditionalSenseCodeQualifier = cur_sense_data.ascq; + tb.sense_data->FieldReplaceableUnitCode = 0; + tb.sense_data->SKSV = 0; + tb.sense_data->SenseKeySpecific = 0; + logf("scsi request_sense %d", lun); + send_command_result(tb.sense_data, sizeof(struct sense_data)); break; } - /*unsigned char pc = (cbw->command_block[2] & 0xc0) >>6;*/ - unsigned char page_code = cbw->command_block[2] & 0x3f; - logf("scsi mode_sense_10 %d %X",lun,page_code); - switch(page_code) { - case 0x3f: - tb.ms_data_10->mode_data_length = - htobe16(sizeof(struct mode_sense_data_10)-2); - tb.ms_data_10->medium_type = 0; - tb.ms_data_10->device_specific = 0; - tb.ms_data_10->reserved = 0; - tb.ms_data_10->longlba = 1; - tb.ms_data_10->block_descriptor_length = - htobe16(sizeof(struct mode_sense_bdesc_longlba)); - memset(tb.ms_data_10->block_descriptor.reserved,0,4); - memset(tb.ms_data_10->block_descriptor.num_blocks,0,8); - - tb.ms_data_10->block_descriptor.num_blocks[4] = - ((block_count/block_size_mult) & 0xff000000)>>24; - tb.ms_data_10->block_descriptor.num_blocks[5] = - ((block_count/block_size_mult) & 0x00ff0000)>>16; - tb.ms_data_10->block_descriptor.num_blocks[6] = - ((block_count/block_size_mult) & 0x0000ff00)>>8; - tb.ms_data_10->block_descriptor.num_blocks[7] = - ((block_count/block_size_mult) & 0x000000ff); - - tb.ms_data_10->block_descriptor.block_size[0] = - ((block_size*block_size_mult) & 0xff000000)>>24; - tb.ms_data_10->block_descriptor.block_size[1] = - ((block_size*block_size_mult) & 0x00ff0000)>>16; - tb.ms_data_10->block_descriptor.block_size[2] = - ((block_size*block_size_mult) & 0x0000ff00)>>8; - tb.ms_data_10->block_descriptor.block_size[3] = - ((block_size*block_size_mult) & 0x000000ff); - send_command_result(tb.ms_data_10, - MIN(sizeof(struct mode_sense_data_10), length)); - break; - default: + case SCSI_MODE_SENSE_10: + { + if (!lun_present) + { send_command_failed_result(); - cur_sense_data.sense_key=SENSE_ILLEGAL_REQUEST; - cur_sense_data.asc=ASC_INVALID_FIELD_IN_CBD; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = SENSE_NOT_READY; + cur_sense_data.asc = ASC_MEDIUM_NOT_PRESENT; + cur_sense_data.ascq = 0; break; } - break; - } - case SCSI_MODE_SENSE_6: { - if(! lun_present) { - send_command_failed_result(); - cur_sense_data.sense_key=SENSE_NOT_READY; - cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; - cur_sense_data.ascq=0; + /*unsigned char pc = (cbw->command_block[2] & 0xc0) >>6;*/ + unsigned char page_code = cbw->command_block[2] & 0x3f; + logf("scsi mode_sense_10 %d %X", lun, page_code); + switch (page_code) + { + case 0x3f: + tb.ms_data_10->mode_data_length = + htobe16(sizeof(struct mode_sense_data_10) - 2); + tb.ms_data_10->medium_type = 0; + tb.ms_data_10->device_specific = 0; + tb.ms_data_10->reserved = 0; + tb.ms_data_10->longlba = 1; + tb.ms_data_10->block_descriptor_length = + htobe16(sizeof(struct mode_sense_bdesc_longlba)); + + memset(tb.ms_data_10->block_descriptor.reserved, 0, 4); + memset(tb.ms_data_10->block_descriptor.num_blocks, 0, 8); + + tb.ms_data_10->block_descriptor.num_blocks[4] = + ((block_count / block_size_mult) & 0xff000000) >> 24; + tb.ms_data_10->block_descriptor.num_blocks[5] = + ((block_count / block_size_mult) & 0x00ff0000) >> 16; + tb.ms_data_10->block_descriptor.num_blocks[6] = + ((block_count / block_size_mult) & 0x0000ff00) >> 8; + tb.ms_data_10->block_descriptor.num_blocks[7] = + ((block_count / block_size_mult) & 0x000000ff); + + tb.ms_data_10->block_descriptor.block_size[0] = + ((block_size * block_size_mult) & 0xff000000) >> 24; + tb.ms_data_10->block_descriptor.block_size[1] = + ((block_size * block_size_mult) & 0x00ff0000) >> 16; + tb.ms_data_10->block_descriptor.block_size[2] = + ((block_size * block_size_mult) & 0x0000ff00) >> 8; + tb.ms_data_10->block_descriptor.block_size[3] = + ((block_size * block_size_mult) & 0x000000ff); + send_command_result(tb.ms_data_10, + MIN(sizeof(struct mode_sense_data_10), length)); + break; + default: + send_command_failed_result(); + cur_sense_data.sense_key = SENSE_ILLEGAL_REQUEST; + cur_sense_data.asc = ASC_INVALID_FIELD_IN_CBD; + cur_sense_data.ascq = 0; + break; + } break; } - /*unsigned char pc = (cbw->command_block[2] & 0xc0) >>6;*/ - unsigned char page_code = cbw->command_block[2] & 0x3f; - logf("scsi mode_sense_6 %d %X",lun,page_code); - switch(page_code) { - case 0x3f: - /* All supported pages. */ - tb.ms_data_6->mode_data_length = - sizeof(struct mode_sense_data_6)-1; - tb.ms_data_6->medium_type = 0; - tb.ms_data_6->device_specific = 0; - tb.ms_data_6->block_descriptor_length = - sizeof(struct mode_sense_bdesc_shortlba); - tb.ms_data_6->block_descriptor.density_code = 0; - tb.ms_data_6->block_descriptor.reserved = 0; - if(block_count/block_size_mult > 0xffffff){ - tb.ms_data_6->block_descriptor.num_blocks[0] = 0xff; - tb.ms_data_6->block_descriptor.num_blocks[1] = 0xff; - tb.ms_data_6->block_descriptor.num_blocks[2] = 0xff; - } - else { - tb.ms_data_6->block_descriptor.num_blocks[0] = - ((block_count/block_size_mult) & 0xff0000)>>16; - tb.ms_data_6->block_descriptor.num_blocks[1] = - ((block_count/block_size_mult) & 0x00ff00)>>8; - tb.ms_data_6->block_descriptor.num_blocks[2] = - ((block_count/block_size_mult) & 0x0000ff); - } - tb.ms_data_6->block_descriptor.block_size[0] = - ((block_size*block_size_mult) & 0xff0000)>>16; - tb.ms_data_6->block_descriptor.block_size[1] = - ((block_size*block_size_mult) & 0x00ff00)>>8; - tb.ms_data_6->block_descriptor.block_size[2] = - ((block_size*block_size_mult) & 0x0000ff); - send_command_result(tb.ms_data_6, - MIN(sizeof(struct mode_sense_data_6), length)); - break; - default: + case SCSI_MODE_SENSE_6: + { + if (!lun_present) + { send_command_failed_result(); - cur_sense_data.sense_key=SENSE_ILLEGAL_REQUEST; - cur_sense_data.asc=ASC_INVALID_FIELD_IN_CBD; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = SENSE_NOT_READY; + cur_sense_data.asc = ASC_MEDIUM_NOT_PRESENT; + cur_sense_data.ascq = 0; break; + } + /*unsigned char pc = (cbw->command_block[2] & 0xc0) >>6;*/ + unsigned char page_code = cbw->command_block[2] & 0x3f; + logf("scsi mode_sense_6 %d %X", lun, page_code); + switch (page_code) + { + case 0x3f: + /* All supported pages. */ + tb.ms_data_6->mode_data_length = + sizeof(struct mode_sense_data_6) - 1; + tb.ms_data_6->medium_type = 0; + tb.ms_data_6->device_specific = 0; + tb.ms_data_6->block_descriptor_length = + sizeof(struct mode_sense_bdesc_shortlba); + tb.ms_data_6->block_descriptor.density_code = 0; + tb.ms_data_6->block_descriptor.reserved = 0; + if (block_count / block_size_mult > 0xffffff) + { + tb.ms_data_6->block_descriptor.num_blocks[0] = 0xff; + tb.ms_data_6->block_descriptor.num_blocks[1] = 0xff; + tb.ms_data_6->block_descriptor.num_blocks[2] = 0xff; + } + else + { + tb.ms_data_6->block_descriptor.num_blocks[0] = + ((block_count / block_size_mult) & 0xff0000) >> 16; + tb.ms_data_6->block_descriptor.num_blocks[1] = + ((block_count / block_size_mult) & 0x00ff00) >> 8; + tb.ms_data_6->block_descriptor.num_blocks[2] = + ((block_count / block_size_mult) & 0x0000ff); + } + tb.ms_data_6->block_descriptor.block_size[0] = + ((block_size * block_size_mult) & 0xff0000) >> 16; + tb.ms_data_6->block_descriptor.block_size[1] = + ((block_size * block_size_mult) & 0x00ff00) >> 8; + tb.ms_data_6->block_descriptor.block_size[2] = + ((block_size * block_size_mult) & 0x0000ff); + send_command_result(tb.ms_data_6, + MIN(sizeof(struct mode_sense_data_6), length)); + break; + default: + send_command_failed_result(); + cur_sense_data.sense_key = SENSE_ILLEGAL_REQUEST; + cur_sense_data.asc = ASC_INVALID_FIELD_IN_CBD; + cur_sense_data.ascq = 0; + break; + } + break; } - break; - } case SCSI_START_STOP_UNIT: - logf("scsi start_stop unit %d",lun); - if((cbw->command_block[4] & 0xf0) == 0) /*load/eject bit is valid*/ + logf("scsi start_stop unit %d", lun); + if ((cbw->command_block[4] & 0xf0) == 0) /*load/eject bit is valid*/ { /* Process start and eject bits */ logf("scsi load/eject"); - if((cbw->command_block[4] & 0x01) == 0) /* Don't start */ + if ((cbw->command_block[4] & 0x01) == 0) /* Don't start */ { - if((cbw->command_block[4] & 0x02) != 0) /* eject */ + if ((cbw->command_block[4] & 0x02) != 0) /* eject */ { logf("scsi eject"); - ejected[lun]=true; + ejected[lun] = true; } } } @@ -909,112 +965,119 @@ break; case SCSI_ALLOW_MEDIUM_REMOVAL: - logf("scsi allow_medium_removal %d",lun); - if((cbw->command_block[4] & 0x03) == 0) + logf("scsi allow_medium_removal %d", lun); + if ((cbw->command_block[4] & 0x03) == 0) { - locked[lun]=false; - queue_broadcast(SYS_USB_LUN_LOCKED, (lun<<16)+0); + locked[lun] = false; + queue_broadcast(SYS_USB_LUN_LOCKED, (lun << 16) + 0); } else { - locked[lun]=true; - queue_broadcast(SYS_USB_LUN_LOCKED, (lun<<16)+1); + locked[lun] = true; + queue_broadcast(SYS_USB_LUN_LOCKED, (lun << 16) + 1); } send_csw(UMS_STATUS_GOOD); break; - case SCSI_READ_FORMAT_CAPACITY: { - logf("scsi read_format_capacity %d",lun); - if(lun_present) { - tb.format_capacity_data->following_length=htobe32(8); - /* "block count" actually means "number of last block" */ - tb.format_capacity_data->block_count = - htobe32(block_count/block_size_mult - 1); - tb.format_capacity_data->block_size = - htobe32(block_size*block_size_mult); - tb.format_capacity_data->block_size |= - htobe32(SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA); - send_command_result(tb.format_capacity_data, - MIN(sizeof(struct format_capacity), length)); - } - else + case SCSI_READ_FORMAT_CAPACITY: { - send_command_failed_result(); - cur_sense_data.sense_key=SENSE_NOT_READY; - cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; - cur_sense_data.ascq=0; + logf("scsi read_format_capacity %d", lun); + if (lun_present) + { + tb.format_capacity_data->following_length = htobe32(8); + /* "block count" actually means "number of last block" */ + tb.format_capacity_data->block_count = + htobe32(block_count / block_size_mult - 1); + tb.format_capacity_data->block_size = + htobe32(block_size * block_size_mult); + tb.format_capacity_data->block_size |= + htobe32(SCSI_FORMAT_CAPACITY_FORMATTED_MEDIA); + + send_command_result(tb.format_capacity_data, + MIN(sizeof(struct format_capacity), length)); + } + else + { + send_command_failed_result(); + cur_sense_data.sense_key = SENSE_NOT_READY; + cur_sense_data.asc = ASC_MEDIUM_NOT_PRESENT; + cur_sense_data.ascq = 0; + } + break; } - break; - } - case SCSI_READ_CAPACITY: { - logf("scsi read_capacity %d",lun); - if(lun_present) { - /* "block count" actually means "number of last block" */ - tb.capacity_data->block_count = - htobe32(block_count/block_size_mult - 1); - tb.capacity_data->block_size = - htobe32(block_size*block_size_mult); + case SCSI_READ_CAPACITY: + { + logf("scsi read_capacity %d", lun); - send_command_result(tb.capacity_data, - MIN(sizeof(struct capacity), length)); + if (lun_present) + { + /* "block count" actually means "number of last block" */ + tb.capacity_data->block_count = + htobe32(block_count / block_size_mult - 1); + tb.capacity_data->block_size = + htobe32(block_size * block_size_mult); + + send_command_result(tb.capacity_data, + MIN(sizeof(struct capacity), length)); + } + else + { + send_command_failed_result(); + cur_sense_data.sense_key = SENSE_NOT_READY; + cur_sense_data.asc = ASC_MEDIUM_NOT_PRESENT; + cur_sense_data.ascq = 0; + } + break; } - else - { - send_command_failed_result(); - cur_sense_data.sense_key=SENSE_NOT_READY; - cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; - cur_sense_data.ascq=0; - } - break; - } case SCSI_READ_10: - logf("scsi read10 %d",lun); - if(! lun_present) { + logf("scsi read10 %d", lun); + if (!lun_present) + { send_command_failed_result(); - cur_sense_data.sense_key=SENSE_NOT_READY; - cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = SENSE_NOT_READY; + cur_sense_data.asc = ASC_MEDIUM_NOT_PRESENT; + cur_sense_data.ascq = 0; break; } cur_cmd.data[0] = tb.transfer_buffer; cur_cmd.data[1] = &tb.transfer_buffer[BUFFER_SIZE]; - cur_cmd.data_select=0; + cur_cmd.data_select = 0; cur_cmd.sector = block_size_mult * - (cbw->command_block[2] << 24 | - cbw->command_block[3] << 16 | - cbw->command_block[4] << 8 | - cbw->command_block[5] ); + (cbw->command_block[2] << 24 | + cbw->command_block[3] << 16 | + cbw->command_block[4] << 8 | + cbw->command_block[5] ); cur_cmd.count = block_size_mult * - (cbw->command_block[7] << 8 | - cbw->command_block[8]); + (cbw->command_block[7] << 8 | + cbw->command_block[8]); cur_cmd.orig_count = cur_cmd.count; //logf("scsi read %d %d", cur_cmd.sector, cur_cmd.count); - if((cur_cmd.sector + cur_cmd.count) > block_count) { + if ((cur_cmd.sector + cur_cmd.count) > block_count) + { send_csw(UMS_STATUS_FAIL); - cur_sense_data.sense_key=SENSE_ILLEGAL_REQUEST; - cur_sense_data.asc=ASC_LBA_OUT_OF_RANGE; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = SENSE_ILLEGAL_REQUEST; + cur_sense_data.asc = ASC_LBA_OUT_OF_RANGE; + cur_sense_data.ascq = 0; } - else { + else + { #ifdef USB_USE_RAMDISK memcpy(cur_cmd.data[cur_cmd.data_select], - ramdisk_buffer + cur_cmd.sector*SECTOR_SIZE, - MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count)*SECTOR_SIZE); + ramdisk_buffer + cur_cmd.sector * SECTOR_SIZE, + MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count)*SECTOR_SIZE); #else cur_cmd.last_result = storage_read_sectors(cur_cmd.lun, - cur_cmd.sector, - MIN(BUFFER_SIZE/SECTOR_SIZE, - cur_cmd.count), - cur_cmd.data[cur_cmd.data_select]); + cur_cmd.sector, + MIN(BUFFER_SIZE/SECTOR_SIZE, cur_cmd.count), + cur_cmd.data[cur_cmd.data_select]); #ifdef TOSHIBA_GIGABEAT_S - if (cur_cmd.sector == 0) { + if (cur_cmd.sector == 0) fix_mbr(cur_cmd.data[cur_cmd.data_select]); - } #endif #endif send_and_read_next(); @@ -1022,61 +1085,62 @@ break; case SCSI_WRITE_10: - logf("scsi write10 %d",lun); - if(! lun_present) { + logf("scsi write10 %d", lun); + if (!lun_present) + { send_csw(UMS_STATUS_FAIL); - cur_sense_data.sense_key=SENSE_NOT_READY; - cur_sense_data.asc=ASC_MEDIUM_NOT_PRESENT; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = SENSE_NOT_READY; + cur_sense_data.asc = ASC_MEDIUM_NOT_PRESENT; + cur_sense_data.ascq = 0; break; } cur_cmd.data[0] = tb.transfer_buffer; cur_cmd.data[1] = &tb.transfer_buffer[BUFFER_SIZE]; - cur_cmd.data_select=0; + cur_cmd.data_select = 0; cur_cmd.sector = block_size_mult * - (cbw->command_block[2] << 24 | - cbw->command_block[3] << 16 | - cbw->command_block[4] << 8 | - cbw->command_block[5] ); + (cbw->command_block[2] << 24 | + cbw->command_block[3] << 16 | + cbw->command_block[4] << 8 | + cbw->command_block[5] ); cur_cmd.count = block_size_mult * - (cbw->command_block[7] << 8 | - cbw->command_block[8]); + (cbw->command_block[7] << 8 | + cbw->command_block[8]); cur_cmd.orig_count = cur_cmd.count; /* expect data */ - if((cur_cmd.sector + cur_cmd.count) > block_count) { + if ((cur_cmd.sector + cur_cmd.count) > block_count) + { send_csw(UMS_STATUS_FAIL); - cur_sense_data.sense_key=SENSE_ILLEGAL_REQUEST; - cur_sense_data.asc=ASC_LBA_OUT_OF_RANGE; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = SENSE_ILLEGAL_REQUEST; + cur_sense_data.asc = ASC_LBA_OUT_OF_RANGE; + cur_sense_data.ascq = 0; } - else { + else + { receive_block_data(cur_cmd.data[0], - MIN(BUFFER_SIZE, - cur_cmd.count*SECTOR_SIZE)); + MIN(BUFFER_SIZE, cur_cmd.count * SECTOR_SIZE)); } - break; default: - logf("scsi unknown cmd %x",cbw->command_block[0x0]); + logf("scsi unknown cmd %x", cbw->command_block[0x0]); send_csw(UMS_STATUS_FAIL); - cur_sense_data.sense_key=SENSE_ILLEGAL_REQUEST; - cur_sense_data.asc=ASC_INVALID_COMMAND; - cur_sense_data.ascq=0; + cur_sense_data.sense_key = SENSE_ILLEGAL_REQUEST; + cur_sense_data.asc = ASC_INVALID_COMMAND; + cur_sense_data.ascq = 0; break; } } -static void send_block_data(void *data,int size) +static void send_block_data(void *data, int size) { - usb_drv_send_nonblocking(ep_in, data,size); + usb_drv_send_nonblocking(ep_in, data, size); state = SENDING_BLOCKS; } -static void send_command_result(void *data,int size) +static void send_command_result(void *data, int size) { - usb_drv_send_nonblocking(ep_in, data,size); + usb_drv_send_nonblocking(ep_in, data, size); state = SENDING_RESULT; } @@ -1086,7 +1150,7 @@ state = SENDING_FAILED_RESULT; } -static void receive_block_data(void *data,int size) +static void receive_block_data(void *data, int size) { usb_drv_recv(ep_out, data, size); state = RECEIVING_BLOCKS; @@ -1100,27 +1164,28 @@ tb.csw->status = status; usb_drv_send_nonblocking(ep_in, tb.csw, - sizeof(struct command_status_wrapper)); + sizeof(struct command_status_wrapper)); state = SENDING_CSW; - //logf("CSW: %X",status); + //logf("CSW: %X", status); - if(status == UMS_STATUS_GOOD) { - cur_sense_data.sense_key=0; - cur_sense_data.information=0; - cur_sense_data.asc=0; - cur_sense_data.ascq=0; + if (status == UMS_STATUS_GOOD) + { + cur_sense_data.sense_key = 0; + cur_sense_data.information = 0; + cur_sense_data.asc = 0; + cur_sense_data.ascq = 0; } } static void copy_padded(char *dest, char *src, int len) { - int i=0; - while(src[i]!=0 && iVendorId,info.vendor,sizeof(tb.inquiry->VendorId)); - copy_padded(tb.inquiry->ProductId,info.product,sizeof(tb.inquiry->ProductId)); - copy_padded(tb.inquiry->ProductRevisionLevel,info.revision,sizeof(tb.inquiry->ProductRevisionLevel)); + memset(tb.inquiry, 0, sizeof(struct inquiry_data)); + storage_get_info(lun, &info); + copy_padded(tb.inquiry->VendorId, info.vendor, sizeof(tb.inquiry->VendorId)); + copy_padded(tb.inquiry->ProductId, info.product, sizeof(tb.inquiry->ProductId)); + copy_padded(tb.inquiry->ProductRevisionLevel, info.revision, + sizeof(tb.inquiry->ProductRevisionLevel)); + tb.inquiry->DeviceType = DIRECT_ACCESS_DEVICE; tb.inquiry->AdditionalLength = 0x1f; memset(tb.inquiry->Reserved, 0, 3); tb.inquiry->Versions = 4; /* SPC-2 */ - tb.inquiry->Format = 2; /* SPC-2/3 inquiry format */ + tb.inquiry->Format = 2; /* SPC-2/3 inquiry format */ #ifdef TOSHIBA_GIGABEAT_S tb.inquiry->DeviceTypeModifier = 0; Index: firmware/export/usb_core.h =================================================================== --- firmware/export/usb_core.h (revision 20662) +++ firmware/export/usb_core.h (working copy) @@ -45,10 +45,10 @@ void usb_core_transfer_complete(int endpoint, int dir, int status, int length); void usb_core_bus_reset(void); bool usb_core_any_exclusive_storage(void); -void usb_core_enable_driver(int driver,bool enabled); +void usb_core_enable_driver(int driver, bool enabled); bool usb_core_driver_enabled (int driver); void usb_core_handle_transfer_completion( - struct usb_transfer_completion_event_data* event); + struct usb_transfer_completion_event_data* event); int usb_core_ack_control(struct usb_ctrlrequest* req); int usb_core_request_endpoint(int dir, struct usb_class_driver *drv); Index: firmware/export/usb.h =================================================================== --- firmware/export/usb.h (revision 20662) +++ firmware/export/usb.h (working copy) @@ -89,10 +89,12 @@ #ifdef HAVE_USBSTACK /* USB class drivers */ -enum { +enum +{ USB_DRIVER_MASS_STORAGE, USB_DRIVER_SERIAL, USB_DRIVER_CHARGING_ONLY, + USB_DRIVER_HID, USB_NUM_DRIVERS }; #endif @@ -103,11 +105,10 @@ int dir; int status; int length; - void* data; + void *data; }; #endif - void usb_init(void); void usb_enable(bool on); void usb_attach(void); @@ -116,8 +117,10 @@ void usb_acknowledge(long id); void usb_wait_for_disconnect(struct event_queue *q); int usb_wait_for_disconnect_w_tmo(struct event_queue *q, int ticks); -bool usb_inserted(void); /* return the official value, what's been reported to the threads */ -int usb_detect(void); /* return the raw hardware value - nothing/pc/charger */ +/* return the official value, what's been reported to the threads */ +bool usb_inserted(void); +/* return the raw hardware value - nothing / pc / charger */ +int usb_detect(void); /* For tick-less USB monitoring (USB_STATUS_BY_EVENT) */ void usb_status_event(int current_status); #ifdef HAVE_USB_POWER @@ -128,7 +131,8 @@ #endif #endif #ifdef HAVE_USBSTACK -void usb_signal_transfer_completion(struct usb_transfer_completion_event_data* event_data); +void usb_signal_transfer_completion( + struct usb_transfer_completion_event_data *event_data); bool usb_driver_enabled(int driver); bool usb_exclusive_storage(void); /* storage is available for usb */ void usb_storage_try_release_storage(void); Index: firmware/usbstack/usb_class_driver.h =================================================================== --- firmware/usbstack/usb_class_driver.h (revision 20662) +++ firmware/usbstack/usb_class_driver.h (working copy) @@ -24,15 +24,16 @@ /* Common api, implemented by all class drivers */ -struct usb_class_driver { - /* First some runtime data */ +struct usb_class_driver +{ + /* First some runtime data */ bool enabled; int first_interface; int last_interface; - /* Driver api starts here */ + /* Driver api starts here */ - /* Set this to true if the driver needs exclusive disk access (e.g. usb storage) */ + /* Set this to true if the driver needs exclusive disk access (e.g. usb storage) */ bool needs_exclusive_storage; /* Let the driver request endpoints it need. Returns zero on success */ @@ -52,7 +53,7 @@ int (*get_config_descriptor)(unsigned char *dest, int max_packet_size); /* Tells the driver that a usb connection has been set up and is now - ready to use. + ready to use. Optional function */ void (*init_connection)(void); @@ -62,24 +63,24 @@ Optional function */ void (*init)(void); - /* Tells the driver that the usb connection is no longer active + /* Tells the driver that the usb connection is no longer active Optional function */ void (*disconnect)(void); /* Tells the driver that a usb transfer has been completed. Note that "dir" - is relative to the host + is relative to the host Optional function */ void (*transfer_complete)(int ep,int dir, int status, int length); /* Tells the driver that a control request has come in. If the driver is able to handle it, it should ack the request, and return true. Otherwise - it should return false. + it should return false. Optional function */ bool (*control_request)(struct usb_ctrlrequest* req); #ifdef HAVE_HOTSWAP /* Tells the driver that a hotswappable disk/card was inserted or - extracted + extracted Optional function */ void (*notify_hotswap)(int volume, bool inserted); #endif Index: apps/debug_menu.c =================================================================== --- apps/debug_menu.c (revision 20662) +++ apps/debug_menu.c (working copy) @@ -683,7 +683,7 @@ lcd_update(); while (!(action_userabort(TIMEOUT_BLOCK))); - + #else /* Define this function in your target tree */ return __dbg_hw_info(); @@ -1757,7 +1757,7 @@ /* Conversion disabled */ snprintf(buf, 30, "T Battery: ?"); } - + lcd_puts(0, line++, buf); #elif defined(SANSA_E200) || defined(SANSA_C200) || defined(SANSA_CLIP) const int first = CHARGE_STATE_DISABLED; @@ -1782,7 +1782,7 @@ str ? str : ""); lcd_puts(0, 4, buf); - snprintf(buf, sizeof(buf), "CHARGER: %02X", + snprintf(buf, sizeof(buf), "CHARGER: %02X", ascodec_read(AS3514_CHARGER)); lcd_puts(0, 5, buf); #else @@ -1962,7 +1962,7 @@ } return btn; } -#elif (CONFIG_STORAGE & STORAGE_ATA) +#elif (CONFIG_STORAGE & STORAGE_ATA) static int disk_callback(int btn, struct gui_synclist *lists) { (void)lists; @@ -2116,7 +2116,7 @@ } #endif -#if (CONFIG_STORAGE & STORAGE_ATA) +#if (CONFIG_STORAGE & STORAGE_ATA) static bool dbg_identify_info(void) { int fd = creat("/identify_info.bin"); @@ -2210,9 +2210,9 @@ simplelist_addline(SIMPLELIST_ADD_LINE, "Commit delayed: %s", stat->commit_delayed ? "Yes" : "No"); - simplelist_addline(SIMPLELIST_ADD_LINE, "Queue length: %d", + simplelist_addline(SIMPLELIST_ADD_LINE, "Queue length: %d", stat->queue_length); - + if (synced) { synced = false; @@ -2237,7 +2237,7 @@ info.action_callback = database_callback; info.hide_selection = true; info.scroll_all = true; - + /* Don't do nonblock here, must give enough processing time for tagcache thread. */ /* info.timeout = TIMEOUT_NOBLOCK; */ @@ -2587,9 +2587,10 @@ static bool logf_usb_serial(void) { bool serial_enabled = !usb_core_driver_enabled(USB_DRIVER_SERIAL); - usb_core_enable_driver(USB_DRIVER_SERIAL,serial_enabled); - splashf(HZ, "USB logf %s", - serial_enabled?"enabled":"disabled"); + + usb_core_enable_driver(USB_DRIVER_SERIAL, serial_enabled); + splashf(HZ, "USB logf %s", serial_enabled ? "enabled" : "disabled"); + return false; } #endif @@ -2611,7 +2612,7 @@ struct simplelist_info isp1583; isp1583.scroll_all = true; simplelist_info_init(&isp1583, "ISP1583", dbg_usb_num_items(), NULL); - isp1583.timeout = HZ/100; + isp1583.timeout = HZ/100; isp1583.hide_selection = true; isp1583.get_name = dbg_usb_item; isp1583.action_callback = isp1583_action_callback; @@ -2636,7 +2637,7 @@ struct simplelist_info pic; pic.scroll_all = true; simplelist_info_init(&pic, "PIC", pic_dbg_num_items(), NULL); - pic.timeout = HZ/100; + pic.timeout = HZ/100; pic.hide_selection = true; pic.get_name = pic_dbg_item; pic.action_callback = pic_action_callback; @@ -2729,13 +2730,13 @@ {"logfdump", logfdump }, #endif #if defined(HAVE_USBSTACK) && defined(ROCKBOX_HAS_LOGF) && defined(USB_SERIAL) - {"logf over usb",logf_usb_serial }, + {"logf over usb", logf_usb_serial }, #endif #if 0 && defined(HAVE_USBSTACK) && defined(USB_STORAGE) {"reconnect usb storage",usb_reconnect}, #endif #ifdef CPU_BOOST_LOGGING - {"cpu_boost log",cpu_boost_log}, + {"cpu_boost log", cpu_boost_log}, #endif #if (defined(HAVE_WHEEL_ACCELERATION) && (CONFIG_KEYPAD==IPOD_4G_PAD) && !defined(SIMULATOR)) {"Debug scrollwheel", dbg_scrollwheel}, Index: firmware/target/arm/usb-drv-arc.c =================================================================== --- firmware/target/arm/usb-drv-arc.c (revision 20662) +++ firmware/target/arm/usb-drv-arc.c (working copy) @@ -35,36 +35,37 @@ /* USB device mode registers (Little Endian) */ -#define REG_ID (*(volatile unsigned int *)(USB_BASE+0x000)) -#define REG_HWGENERAL (*(volatile unsigned int *)(USB_BASE+0x004)) -#define REG_HWHOST (*(volatile unsigned int *)(USB_BASE+0x008)) -#define REG_HWDEVICE (*(volatile unsigned int *)(USB_BASE+0x00c)) -#define REG_TXBUF (*(volatile unsigned int *)(USB_BASE+0x010)) -#define REG_RXBUF (*(volatile unsigned int *)(USB_BASE+0x014)) -#define REG_CAPLENGTH (*(volatile unsigned char*)(USB_BASE+0x100)) -#define REG_DCIVERSION (*(volatile unsigned int *)(USB_BASE+0x120)) -#define REG_DCCPARAMS (*(volatile unsigned int *)(USB_BASE+0x124)) -#define REG_USBCMD (*(volatile unsigned int *)(USB_BASE+0x140)) -#define REG_USBSTS (*(volatile unsigned int *)(USB_BASE+0x144)) -#define REG_USBINTR (*(volatile unsigned int *)(USB_BASE+0x148)) -#define REG_FRINDEX (*(volatile unsigned int *)(USB_BASE+0x14c)) -#define REG_DEVICEADDR (*(volatile unsigned int *)(USB_BASE+0x154)) -#define REG_ENDPOINTLISTADDR (*(volatile unsigned int *)(USB_BASE+0x158)) -#define REG_BURSTSIZE (*(volatile unsigned int *)(USB_BASE+0x160)) -#define REG_ULPI (*(volatile unsigned int *)(USB_BASE+0x170)) -#define REG_CONFIGFLAG (*(volatile unsigned int *)(USB_BASE+0x180)) -#define REG_PORTSC1 (*(volatile unsigned int *)(USB_BASE+0x184)) -#define REG_OTGSC (*(volatile unsigned int *)(USB_BASE+0x1a4)) -#define REG_USBMODE (*(volatile unsigned int *)(USB_BASE+0x1a8)) -#define REG_ENDPTSETUPSTAT (*(volatile unsigned int *)(USB_BASE+0x1ac)) -#define REG_ENDPTPRIME (*(volatile unsigned int *)(USB_BASE+0x1b0)) -#define REG_ENDPTFLUSH (*(volatile unsigned int *)(USB_BASE+0x1b4)) -#define REG_ENDPTSTATUS (*(volatile unsigned int *)(USB_BASE+0x1b8)) -#define REG_ENDPTCOMPLETE (*(volatile unsigned int *)(USB_BASE+0x1bc)) -#define REG_ENDPTCTRL0 (*(volatile unsigned int *)(USB_BASE+0x1c0)) -#define REG_ENDPTCTRL1 (*(volatile unsigned int *)(USB_BASE+0x1c4)) -#define REG_ENDPTCTRL2 (*(volatile unsigned int *)(USB_BASE+0x1c8)) -#define REG_ENDPTCTRL(_x_) (*(volatile unsigned int *)(USB_BASE+0x1c0+4*(_x_))) +#define REG_ID (*(volatile unsigned int *)(USB_BASE + 0x000)) +#define REG_HWGENERAL (*(volatile unsigned int *)(USB_BASE + 0x004)) +#define REG_HWHOST (*(volatile unsigned int *)(USB_BASE + 0x008)) +#define REG_HWDEVICE (*(volatile unsigned int *)(USB_BASE + 0x00c)) +#define REG_TXBUF (*(volatile unsigned int *)(USB_BASE + 0x010)) +#define REG_RXBUF (*(volatile unsigned int *)(USB_BASE + 0x014)) +#define REG_CAPLENGTH (*(volatile unsigned char*)(USB_BASE + 0x100)) +#define REG_DCIVERSION (*(volatile unsigned int *)(USB_BASE + 0x120)) +#define REG_DCCPARAMS (*(volatile unsigned int *)(USB_BASE + 0x124)) +#define REG_USBCMD (*(volatile unsigned int *)(USB_BASE + 0x140)) +#define REG_USBSTS (*(volatile unsigned int *)(USB_BASE + 0x144)) +#define REG_USBINTR (*(volatile unsigned int *)(USB_BASE + 0x148)) +#define REG_FRINDEX (*(volatile unsigned int *)(USB_BASE + 0x14c)) +#define REG_DEVICEADDR (*(volatile unsigned int *)(USB_BASE + 0x154)) +#define REG_ENDPOINTLISTADDR (*(volatile unsigned int *)(USB_BASE + 0x158)) +#define REG_BURSTSIZE (*(volatile unsigned int *)(USB_BASE + 0x160)) +#define REG_ULPI (*(volatile unsigned int *)(USB_BASE + 0x170)) +#define REG_CONFIGFLAG (*(volatile unsigned int *)(USB_BASE + 0x180)) +#define REG_PORTSC1 (*(volatile unsigned int *)(USB_BASE + 0x184)) +#define REG_OTGSC (*(volatile unsigned int *)(USB_BASE + 0x1a4)) +#define REG_USBMODE (*(volatile unsigned int *)(USB_BASE + 0x1a8)) +#define REG_ENDPTSETUPSTAT (*(volatile unsigned int *)(USB_BASE + 0x1ac)) +#define REG_ENDPTPRIME (*(volatile unsigned int *)(USB_BASE + 0x1b0)) +#define REG_ENDPTFLUSH (*(volatile unsigned int *)(USB_BASE + 0x1b4)) +#define REG_ENDPTSTATUS (*(volatile unsigned int *)(USB_BASE + 0x1b8)) +#define REG_ENDPTCOMPLETE (*(volatile unsigned int *)(USB_BASE + 0x1bc)) +#define REG_ENDPTCTRL0 (*(volatile unsigned int *)(USB_BASE + 0x1c0)) +#define REG_ENDPTCTRL1 (*(volatile unsigned int *)(USB_BASE + 0x1c4)) +#define REG_ENDPTCTRL2 (*(volatile unsigned int *)(USB_BASE + 0x1c8)) +#define REG_ENDPTCTRL(_x_) (*(volatile unsigned int *)(USB_BASE + 0x1c0 + \ + 4 * (_x_))) /* Frame Index Register Bit Masks */ #define USB_FRINDEX_MASKS (0x3fff) @@ -330,7 +331,8 @@ USB_DEVBSS_ATTR __attribute__((aligned(32))); /* manual: 32.13.1 Endpoint Queue Head (dQH) */ -struct queue_head { +struct queue_head +{ unsigned int max_pkt_length; /* Mult(31-30) , Zlt(29) , Max Pkt len and IOS(15) */ unsigned int curr_dtd_ptr; /* Current dTD Pointer(31-5) */ @@ -342,13 +344,14 @@ unsigned int wait; /* for softwate use, indicates if the transfer is blocking */ } __attribute__((packed)); -static struct queue_head qh_array[USB_NUM_ENDPOINTS*2] +static struct queue_head qh_array[USB_NUM_ENDPOINTS * 2] USB_QHARRAY_ATTR; -static struct wakeup transfer_completion_signal[USB_NUM_ENDPOINTS*2] +static struct wakeup transfer_completion_signal[USB_NUM_ENDPOINTS * 2] SHAREDBSS_ATTR; -static const unsigned int pipe2mask[] = { +static const unsigned int pipe2mask[] = +{ 0x01, 0x010000, 0x02, 0x020000, 0x04, 0x040000, @@ -394,7 +397,7 @@ while (REG_USBCMD & USBCMD_CTRL_RESET); #if CONFIG_CPU == PP5022 || CONFIG_CPU == PP5024 - /* On a CPU which identifies as a PP5022, this + /* On a CPU which identifies as a PP5022, this initialization must be done after USB is reset. */ outl(inl(0x70000060) | 0xF, 0x70000060); @@ -421,11 +424,11 @@ /* One-time driver startup init */ void usb_drv_startup(void) { + int i; + /* Initialize all the signal objects once */ - int i; - for(i=0;istatus = 0; - qh->wait = wait; + qh->wait = wait; - new_td=&td_array[pipe*NUM_TDS_PER_EP]; - cur_td=new_td; - prev_td=0; + new_td = &td_array[pipe * NUM_TDS_PER_EP]; + cur_td = new_td; + prev_td = 0; int tdlen; do { - tdlen=MIN(len,16384); + tdlen = MIN(len, 16384); prepare_td(cur_td, prev_td, ptr, tdlen,pipe); - ptr+=tdlen; - prev_td=cur_td; + ptr += tdlen; + prev_td = cur_td; cur_td++; - len-=tdlen; + len -= tdlen; } - while(len>0 ); + while (len > 0); //logf("starting ep %d %s",endpoint,send?"send":"receive"); qh->dtd.next_td_ptr = (unsigned int)new_td; @@ -702,7 +707,8 @@ REG_ENDPTPRIME |= mask; - if(endpoint == EP_CONTROL && (REG_ENDPTSETUPSTAT & EPSETUP_STATUS_EP0)) { + if (endpoint == EP_CONTROL && (REG_ENDPTSETUPSTAT & EPSETUP_STATUS_EP0)) + { /* 32.14.3.2.2 */ logf("new setup arrived"); rc = -4; @@ -710,25 +716,30 @@ } last_tick = current_tick; - while ((REG_ENDPTPRIME & mask)) { - if (REG_USBSTS & USBSTS_RESET) { + while ((REG_ENDPTPRIME & mask)) + { + if (REG_USBSTS & USBSTS_RESET) + { rc = -1; goto pt_error; } - if (TIME_AFTER(current_tick, last_tick + HZ/4)) { + if (TIME_AFTER(current_tick, last_tick + HZ / 4)) + { logf("prime timeout"); rc = -2; goto pt_error; } } - if (!(REG_ENDPTSTATUS & mask)) { - logf("no prime! %d %d %x", endpoint, pipe, qh->dtd.size_ioc_sts & 0xff ); + if (!(REG_ENDPTSTATUS & mask)) + { + logf("no prime! %d %d %x", endpoint, pipe, qh->dtd.size_ioc_sts & 0xff); rc = -3; goto pt_error; } - if(endpoint == EP_CONTROL && (REG_ENDPTSETUPSTAT & EPSETUP_STATUS_EP0)) { + if (endpoint == EP_CONTROL && (REG_ENDPTSETUPSTAT & EPSETUP_STATUS_EP0)) + { /* 32.14.3.2.2 */ logf("new setup arrived"); rc = -4; @@ -737,10 +748,12 @@ restore_irq(oldlevel); - if (wait) { + if (wait) + { /* wait for transfer to finish */ wakeup_wait(&transfer_completion_signal[pipe], TIMEOUT_BLOCK); - if(qh->status!=0) { + if(qh->status) + { /* No need to cancel wait here since it was done and the signal * came. */ return -5; @@ -749,11 +762,12 @@ } pt_error: - if(rc<0) + if(rc < 0) restore_irq(oldlevel); /* Error status must make sure an abandoned wakeup signal isn't left */ - if (rc < 0 && wait) { + if (rc < 0 && wait) + { /* Cancel wait */ qh->wait = 0; /* Make sure to remove any signal if interrupt fired before we zeroed @@ -771,10 +785,12 @@ while (REG_ENDPTFLUSH); memset(td_array, 0, sizeof td_array); - for(i=0;inext_td_ptr = DTD_NEXT_TERMINATE; - td->size_ioc_sts = (len<< DTD_LENGTH_BIT_POS) | + td->size_ioc_sts = (len << DTD_LENGTH_BIT_POS) | DTD_STATUS_ACTIVE | DTD_IOC; td->buff_ptr0 = (unsigned int)ptr; td->buff_ptr1 = ((unsigned int)ptr & 0xfffff000) + 0x1000; @@ -821,9 +840,10 @@ td->reserved |= DTD_RESERVED_IN_USE; td->reserved |= (pipe << DTD_RESERVED_PIPE_OFFSET); - if (previous_td != 0) { - previous_td->next_td_ptr=(unsigned int)td; - previous_td->size_ioc_sts&=~DTD_IOC; + if (previous_td != 0) + { + previous_td->next_td_ptr = (unsigned int)td; + previous_td->size_ioc_sts &= ~DTD_IOC; } } @@ -839,10 +859,12 @@ REG_ENDPTSETUPSTAT = EPSETUP_STATUS_EP0; /* Stop pending control transfers */ - for(i=0;i<2;i++) { - if(qh_array[i].wait) { - qh_array[i].wait=0; - qh_array[i].status=DTD_STATUS_HALTED; + for (i = 0; i < 2; i++) + { + if (qh_array[i].wait) + { + qh_array[i].wait = 0; + qh_array[i].status = DTD_STATUS_HALTED; wakeup_signal(&transfer_completion_signal[i]); } } @@ -856,21 +878,26 @@ unsigned int mask = REG_ENDPTCOMPLETE; REG_ENDPTCOMPLETE = mask; - for (ep=0; epwait) { - qh->wait=0; + + if(qh->wait) + { + qh->wait = 0; wakeup_signal(&transfer_completion_signal[pipe]); } - int length=0; - struct transfer_descriptor* td=&td_array[pipe*NUM_TDS_PER_EP]; - while(td!=(struct transfer_descriptor*)DTD_NEXT_TERMINATE && td!=0) + int length = 0; + struct transfer_descriptor *td = &td_array[pipe*NUM_TDS_PER_EP]; + while (td != (struct transfer_descriptor*)DTD_NEXT_TERMINATE && td != 0) { - length += ((td->reserved & DTD_RESERVED_LENGTH_MASK) - + length += ((td->reserved & DTD_RESERVED_LENGTH_MASK) - ((td->size_ioc_sts & DTD_PACKET_SIZE) >> DTD_LENGTH_BIT_POS)); td=(struct transfer_descriptor*) td->next_td_ptr; } @@ -890,24 +917,28 @@ REG_ENDPTSETUPSTAT = REG_ENDPTSETUPSTAT; REG_ENDPTCOMPLETE = REG_ENDPTCOMPLETE; - for (i=0; i<100; i++) { + for (i = 0; i < 100; i++) + { if (!REG_ENDPTPRIME) break; - if (REG_USBSTS & USBSTS_RESET) { + if (REG_USBSTS & USBSTS_RESET) + { logf("usb: double reset"); return; } udelay(100); } - if (REG_ENDPTPRIME) { + if (REG_ENDPTPRIME) + { logf("usb: short reset timeout"); } usb_drv_cancel_all_transfers(); - - if (!(REG_PORTSC1 & PORTSCX_PORT_RESET)) { + + if (!(REG_PORTSC1 & PORTSCX_PORT_RESET)) + { logf("usb: slow reset!"); } } @@ -920,8 +951,8 @@ /*** control ***/ qh_array[EP_CONTROL].max_pkt_length = 64 << QH_MAX_PKT_LEN_POS | QH_IOS; qh_array[EP_CONTROL].dtd.next_td_ptr = QH_NEXT_TERMINATE; - qh_array[EP_CONTROL+1].max_pkt_length = 64 << QH_MAX_PKT_LEN_POS; - qh_array[EP_CONTROL+1].dtd.next_td_ptr = QH_NEXT_TERMINATE; + qh_array[EP_CONTROL + 1].max_pkt_length = 64 << QH_MAX_PKT_LEN_POS; + qh_array[EP_CONTROL + 1].dtd.next_td_ptr = QH_NEXT_TERMINATE; } /* manual: 32.14.4.1 Queue Head Initialization */ static void init_bulk_queue_heads(void) @@ -930,31 +961,36 @@ int rx_packetsize; int i; - if (usb_drv_port_speed()) { + if (usb_drv_port_speed()) + { rx_packetsize = 512; tx_packetsize = 512; } - else { + else + { rx_packetsize = 64; tx_packetsize = 64; } /* TODO: this should take ep_allocation into account */ /*** bulk ***/ - for(i=1;i