Index: uspace/app/usbinfo/info.c =================================================================== --- uspace/app/usbinfo/info.c (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/app/usbinfo/info.c (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -287,4 +287,19 @@ void dump_strings(usbinfo_device_t *dev) { + /* Find used indexes. Devices with more than 64 strings are very rare.*/ + uint64_t str_mask = 0; + find_string_indexes_callback((uint8_t *)&dev->device_descriptor, 0, + &str_mask); + usb_dp_walk_simple(dev->full_configuration_descriptor, + dev->full_configuration_descriptor_size, + usb_dp_standard_descriptor_nesting, + find_string_indexes_callback, + &str_mask); + + if (str_mask == 0) { + printf("Device does not support string descriptors.\n"); + return; + } + /* Get supported languages. */ l18_win_locales_t *langs; @@ -305,15 +320,4 @@ } printf(".\n"); - - /* Find used indexes. Device with more than 64 strings are very rare. - */ - uint64_t str_mask = 0; - find_string_indexes_callback((uint8_t *)&dev->device_descriptor, 0, - &str_mask); - usb_dp_walk_simple(dev->full_configuration_descriptor, - dev->full_configuration_descriptor_size, - usb_dp_standard_descriptor_nesting, - find_string_indexes_callback, - &str_mask); /* Get all strings and dump them. */ Index: uspace/drv/bus/usb/ohci/hc.c =================================================================== --- uspace/drv/bus/usb/ohci/hc.c (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/drv/bus/usb/ohci/hc.c (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -137,6 +137,4 @@ return ret; } - usb_device_manager_bind_address(&instance->generic.dev_manager, - instance->rh.address, hub_fun->handle); #define CHECK_RET_UNREG_RETURN(ret, message...) \ @@ -166,4 +164,10 @@ "Failed to bind root hub function: %s.\n", str_error(ret)); + ret = usb_device_manager_bind_address(&instance->generic.dev_manager, + instance->rh.address, hub_fun->handle); + if (ret != EOK) + usb_log_warning("Failed to bind root hub address: %s.\n", + str_error(ret)); + return EOK; #undef CHECK_RET_RELEASE Index: uspace/drv/bus/usb/ohci/ohci_batch.c =================================================================== --- uspace/drv/bus/usb/ohci/ohci_batch.c (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/drv/bus/usb/ohci/ohci_batch.c (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -34,4 +34,5 @@ #include #include +#include #include @@ -53,6 +54,9 @@ return; if (ohci_batch->tds) { + const ohci_endpoint_t *ohci_ep = + ohci_endpoint_get(ohci_batch->usb_batch->ep); + assert(ohci_ep); for (unsigned i = 0; i < ohci_batch->td_count; ++i) { - if (i != ohci_batch->leave_td) + if (ohci_batch->tds[i] != ohci_ep->td) free32(ohci_batch->tds[i]); } @@ -64,4 +68,8 @@ } /*----------------------------------------------------------------------------*/ +/** Finishes usb_transfer_batch and destroys the structure. + * + * @param[in] uhci_batch Instance to finish and destroy. + */ void ohci_transfer_batch_finish_dispose(ohci_transfer_batch_t *ohci_batch) { @@ -69,9 +77,18 @@ assert(ohci_batch->usb_batch); usb_transfer_batch_finish(ohci_batch->usb_batch, - ohci_batch->device_buffer + ohci_batch->usb_batch->setup_size, - ohci_batch->usb_batch->buffer_size); + ohci_batch->device_buffer + ohci_batch->usb_batch->setup_size); ohci_transfer_batch_dispose(ohci_batch); } /*----------------------------------------------------------------------------*/ +/** Allocate memory and initialize internal data structure. + * + * @param[in] usb_batch Pointer to generic USB batch structure. + * @return Valid pointer if all structures were successfully created, + * NULL otherwise. + * + * Determines the number of needed transfer descriptors (TDs). + * Prepares a transport buffer (that is accessible by the hardware). + * Initializes parameters needed for the transfer and callback. + */ ohci_transfer_batch_t * ohci_transfer_batch_get(usb_transfer_batch_t *usb_batch) { @@ -105,5 +122,4 @@ ohci_batch->ed = ohci_endpoint_get(usb_batch->ep)->ed; ohci_batch->tds[0] = ohci_endpoint_get(usb_batch->ep)->td; - ohci_batch->leave_td = 0; for (unsigned i = 1; i <= ohci_batch->td_count; ++i) { @@ -152,5 +168,5 @@ * completes with the last TD. */ -bool ohci_transfer_batch_is_complete(ohci_transfer_batch_t *ohci_batch) +bool ohci_transfer_batch_is_complete(const ohci_transfer_batch_t *ohci_batch) { assert(ohci_batch); @@ -174,5 +190,5 @@ /* Assume we will leave the last(unused) TD behind */ - ohci_batch->leave_td = ohci_batch->td_count; + unsigned leave_td = ohci_batch->td_count; /* Check all TDs */ @@ -212,14 +228,14 @@ * It will be the one TD we leave behind. */ - ohci_batch->leave_td = i + 1; + leave_td = i + 1; /* Check TD assumption */ - const uint32_t pa = addr_to_phys( - ohci_batch->tds[ohci_batch->leave_td]); - assert((ohci_batch->ed->td_head & ED_TDTAIL_PTR_MASK) + const uint32_t pa = + addr_to_phys(ohci_batch->tds[leave_td]); + assert((ohci_batch->ed->td_head & ED_TDHEAD_PTR_MASK) == pa); ed_set_tail_td(ohci_batch->ed, - ohci_batch->tds[ohci_batch->leave_td]); + ohci_batch->tds[leave_td]); /* Clear possible ED HALT */ @@ -234,5 +250,5 @@ ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ohci_batch->usb_batch->ep); assert(ohci_ep); - ohci_ep->td = ohci_batch->tds[ohci_batch->leave_td]; + ohci_ep->td = ohci_batch->tds[leave_td]; /* Make sure that we are leaving the right TD behind */ @@ -248,5 +264,5 @@ * @param[in] ohci_batch Batch structure to use */ -void ohci_transfer_batch_commit(ohci_transfer_batch_t *ohci_batch) +void ohci_transfer_batch_commit(const ohci_transfer_batch_t *ohci_batch) { assert(ohci_batch); @@ -295,6 +311,5 @@ while (remain_size > 0) { const size_t transfer_size = - remain_size > OHCI_TD_MAX_TRANSFER ? - OHCI_TD_MAX_TRANSFER : remain_size; + min(remain_size, OHCI_TD_MAX_TRANSFER); toggle = 1 - toggle; @@ -378,4 +393,5 @@ } /*----------------------------------------------------------------------------*/ +/** Transfer setup table. */ static void (*const batch_setup[])(ohci_transfer_batch_t*, usb_direction_t) = { Index: uspace/drv/bus/usb/ohci/ohci_batch.h =================================================================== --- uspace/drv/bus/usb/ohci/ohci_batch.h (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/drv/bus/usb/ohci/ohci_batch.h (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -53,6 +53,4 @@ /** Number of TDs used by the transfer */ size_t td_count; - /** Dummy TD to be left at the ED and used by the next transfer */ - size_t leave_td; /** Data buffer, must be accessible by the OHCI hw. */ char *device_buffer; @@ -62,6 +60,6 @@ ohci_transfer_batch_t * ohci_transfer_batch_get(usb_transfer_batch_t *batch); -bool ohci_transfer_batch_is_complete(ohci_transfer_batch_t *batch); -void ohci_transfer_batch_commit(ohci_transfer_batch_t *batch); +bool ohci_transfer_batch_is_complete(const ohci_transfer_batch_t *batch); +void ohci_transfer_batch_commit(const ohci_transfer_batch_t *batch); void ohci_transfer_batch_finish_dispose(ohci_transfer_batch_t *batch); /*----------------------------------------------------------------------------*/ Index: uspace/drv/bus/usb/ohci/root_hub.c =================================================================== --- uspace/drv/bus/usb/ohci/root_hub.c (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/drv/bus/usb/ohci/root_hub.c (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -100,5 +100,5 @@ .attributes = USB_TRANSFER_INTERRUPT, .descriptor_type = USB_DESCTYPE_ENDPOINT, - .endpoint_address = 1 + (1 << 7), + .endpoint_address = 1 | (1 << 7), .length = sizeof(usb_standard_endpoint_descriptor_t), .max_packet_size = 2, @@ -109,26 +109,33 @@ static void rh_init_descriptors(rh_t *instance); static uint16_t create_interrupt_mask(const rh_t *instance); -static int get_status(const rh_t *instance, usb_transfer_batch_t *request); -static int get_descriptor(const rh_t *instance, usb_transfer_batch_t *request); -static int set_feature(const rh_t *instance, usb_transfer_batch_t *request); -static int clear_feature(const rh_t *instance, usb_transfer_batch_t *request); +static void get_status(const rh_t *instance, usb_transfer_batch_t *request); +static void get_descriptor(const rh_t *instance, usb_transfer_batch_t *request); +static void set_feature(const rh_t *instance, usb_transfer_batch_t *request); +static void clear_feature(const rh_t *instance, usb_transfer_batch_t *request); static int set_feature_port( const rh_t *instance, uint16_t feature, uint16_t port); static int clear_feature_port( const rh_t *instance, uint16_t feature, uint16_t port); -static int control_request(rh_t *instance, usb_transfer_batch_t *request); +static void control_request(rh_t *instance, usb_transfer_batch_t *request); static inline void interrupt_request( usb_transfer_batch_t *request, uint16_t mask, size_t size) { assert(request); - - request->transfered_size = size; usb_transfer_batch_finish_error(request, &mask, size, EOK); -} - -#define TRANSFER_OK(bytes) \ + usb_transfer_batch_destroy(request); +} + +#define TRANSFER_END_DATA(request, data, bytes) \ do { \ - request->transfered_size = bytes; \ - return EOK; \ + usb_transfer_batch_finish_error(request, data, bytes, EOK); \ + usb_transfer_batch_destroy(request); \ + return; \ +} while (0) + +#define TRANSFER_END(request, error) \ +do { \ + usb_transfer_batch_finish_error(request, NULL, 0, error); \ + usb_transfer_batch_destroy(request); \ + return; \ } while (0) @@ -212,7 +219,7 @@ case USB_TRANSFER_CONTROL: usb_log_debug("Root hub got CONTROL packet\n"); - const int ret = control_request(instance, request); - usb_transfer_batch_finish_error(request, NULL, 0, ret); + control_request(instance, request); break; + case USB_TRANSFER_INTERRUPT: usb_log_debug("Root hub got INTERRUPT packet\n"); @@ -221,11 +228,11 @@ const uint16_t mask = create_interrupt_mask(instance); if (mask == 0) { - usb_log_debug("No changes..\n"); + usb_log_debug("No changes...\n"); instance->unfinished_interrupt_transfer = request; - fibril_mutex_unlock(&instance->guard); - return; + } else { + usb_log_debug("Processing changes...\n"); + interrupt_request( + request, mask, instance->interrupt_mask_size); } - usb_log_debug("Processing changes...\n"); - interrupt_request(request, mask, instance->interrupt_mask_size); fibril_mutex_unlock(&instance->guard); break; @@ -233,7 +240,6 @@ default: usb_log_error("Root hub got unsupported request.\n"); - usb_transfer_batch_finish_error(request, NULL, 0, EINVAL); - } - usb_transfer_batch_destroy(request); + TRANSFER_END(request, ENOTSUP); + } } /*----------------------------------------------------------------------------*/ @@ -254,6 +260,4 @@ interrupt_request(instance->unfinished_interrupt_transfer, mask, instance->interrupt_mask_size); - usb_transfer_batch_destroy( - instance->unfinished_interrupt_transfer); instance->unfinished_interrupt_transfer = NULL; } @@ -384,39 +388,80 @@ * @return error code */ -int get_status(const rh_t *instance, usb_transfer_batch_t *request) +void get_status(const rh_t *instance, usb_transfer_batch_t *request) { assert(instance); assert(request); + const usb_device_request_setup_packet_t *request_packet = (usb_device_request_setup_packet_t*)request->setup_buffer; - if (request->buffer_size < 4) { - usb_log_error("Buffer too small for get status request.\n"); - return EOVERFLOW; - } - + switch (request_packet->request_type) + { + case USB_HUB_REQ_TYPE_GET_HUB_STATUS: /* Hub status: just filter relevant info from rh_status reg */ - if (request_packet->request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS) { - const uint32_t data = instance->registers->rh_status & - (RHS_LPS_FLAG | RHS_LPSC_FLAG | RHS_OCI_FLAG | RHS_OCIC_FLAG); - memcpy(request->buffer, &data, sizeof(data)); - TRANSFER_OK(sizeof(data)); - } + if (request->buffer_size < 4) { + usb_log_error("Buffer(%zu) too small for hub get " + "status request.\n", request->buffer_size); + TRANSFER_END(request, EOVERFLOW); + } else { + const uint32_t data = instance->registers->rh_status & + (RHS_LPS_FLAG | RHS_LPSC_FLAG + | RHS_OCI_FLAG | RHS_OCIC_FLAG); + TRANSFER_END_DATA(request, &data, sizeof(data)); + } /* Copy appropriate rh_port_status register, OHCI designers were * kind enough to make those bit values match USB specification */ - if (request_packet->request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS) { - const unsigned port = request_packet->index; - if (port < 1 || port > instance->port_count) - return EINVAL; - - const uint32_t data = - instance->registers->rh_port_status[port - 1]; - memcpy(request->buffer, &data, sizeof(data)); - TRANSFER_OK(sizeof(data)); - } - - return ENOTSUP; + case USB_HUB_REQ_TYPE_GET_PORT_STATUS: + if (request->buffer_size < 4) { + usb_log_error("Buffer(%zu) too small for hub get " + "status request.\n", request->buffer_size); + TRANSFER_END(request, EOVERFLOW); + } else { + const unsigned port = request_packet->index; + if (port < 1 || port > instance->port_count) + TRANSFER_END(request, EINVAL); + + const uint32_t data = + instance->registers->rh_port_status[port - 1]; + TRANSFER_END_DATA(request, &data, sizeof(data)); + } + case SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE): + if (request->buffer_size < 2) { + usb_log_error("Buffer(%zu) too small for hub generic " + "get status request.\n", request->buffer_size); + TRANSFER_END(request, EOVERFLOW); + } else { + static const uint16_t data = + uint16_host2usb(USB_DEVICE_STATUS_SELF_POWERED); + TRANSFER_END_DATA(request, &data, sizeof(data)); + } + + case SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE): + /* Hubs are allowed to have only one interface */ + if (request_packet->index != 0) + TRANSFER_END(request, EINVAL); + /* Fall through, as the answer will be the same: 0x0000 */ + case SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_ENDPOINT): + /* Endpoint 0 (default control) and 1 (interrupt) */ + if (request_packet->index >= 2) + TRANSFER_END(request, EINVAL); + + if (request->buffer_size < 2) { + usb_log_error("Buffer(%zu) too small for hub generic " + "get status request.\n", request->buffer_size); + TRANSFER_END(request, EOVERFLOW); + } else { + /* Endpoints are OK. (We don't halt) */ + static const uint16_t data = 0; + TRANSFER_END_DATA(request, &data, sizeof(data)); + } + + default: + usb_log_error("Unsupported GET_STATUS request.\n"); + TRANSFER_END(request, ENOTSUP); + } + } /*----------------------------------------------------------------------------*/ @@ -430,5 +475,5 @@ * @return Error code */ -int get_descriptor(const rh_t *instance, usb_transfer_batch_t *request) +void get_descriptor(const rh_t *instance, usb_transfer_batch_t *request) { assert(instance); @@ -437,47 +482,45 @@ const usb_device_request_setup_packet_t *setup_request = (usb_device_request_setup_packet_t *) request->setup_buffer; - size_t size; - const void *descriptor = NULL; const uint16_t setup_request_value = setup_request->value_high; - //(setup_request->value_low << 8); switch (setup_request_value) { case USB_DESCTYPE_HUB: usb_log_debug2("USB_DESCTYPE_HUB\n"); - /* Hub descriptor was generated locally */ - descriptor = instance->descriptors.hub; - size = instance->hub_descriptor_size; - break; + /* Hub descriptor was generated locally. + * Class specific request. */ + TRANSFER_END_DATA(request, instance->descriptors.hub, + instance->hub_descriptor_size); case USB_DESCTYPE_DEVICE: usb_log_debug2("USB_DESCTYPE_DEVICE\n"); - /* Device descriptor is shared (No one should ask for it)*/ - descriptor = &ohci_rh_device_descriptor; - size = sizeof(ohci_rh_device_descriptor); - break; + /* Device descriptor is shared + * (No one should ask for it, as the device is already setup) + * Standard USB device request. */ + TRANSFER_END_DATA(request, &ohci_rh_device_descriptor, + sizeof(ohci_rh_device_descriptor)); case USB_DESCTYPE_CONFIGURATION: usb_log_debug2("USB_DESCTYPE_CONFIGURATION\n"); /* Start with configuration and add others depending on - * request size */ - descriptor = &instance->descriptors; - size = instance->descriptors.configuration.total_length; - break; + * request size. Standard USB request. */ + TRANSFER_END_DATA(request, &instance->descriptors, + instance->descriptors.configuration.total_length); case USB_DESCTYPE_INTERFACE: usb_log_debug2("USB_DESCTYPE_INTERFACE\n"); /* Use local interface descriptor. There is one and it - * might be modified */ - descriptor = &instance->descriptors.interface; - size = sizeof(instance->descriptors.interface); - break; + * might be modified. Hub driver should not ask or this + * descriptor as it is not part of standard requests set. */ + TRANSFER_END_DATA(request, &instance->descriptors.interface, + sizeof(instance->descriptors.interface)); case USB_DESCTYPE_ENDPOINT: /* Use local endpoint descriptor. There is one - * it might have max_packet_size field modified*/ + * it might have max_packet_size field modified. Hub driver + * should not ask for this descriptor as it is not part + * of standard requests set. */ usb_log_debug2("USB_DESCTYPE_ENDPOINT\n"); - descriptor = &instance->descriptors.endpoint; - size = sizeof(instance->descriptors.endpoint); - break; + TRANSFER_END_DATA(request, &instance->descriptors.endpoint, + sizeof(instance->descriptors.endpoint)); default: @@ -489,12 +532,8 @@ setup_request_value, setup_request->index, setup_request->length); - return EINVAL; - } - if (request->buffer_size < size) { - size = request->buffer_size; - } - - memcpy(request->buffer, descriptor, size); - TRANSFER_OK(size); + TRANSFER_END(request, EINVAL); + } + + TRANSFER_END(request, ENOTSUP); } /*----------------------------------------------------------------------------*/ @@ -604,5 +643,5 @@ * @return error code */ -int set_feature(const rh_t *instance, usb_transfer_batch_t *request) +void set_feature(const rh_t *instance, usb_transfer_batch_t *request) { assert(instance); @@ -615,6 +654,7 @@ case USB_HUB_REQ_TYPE_SET_PORT_FEATURE: usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n"); - return set_feature_port(instance, + const int ret = set_feature_port(instance, setup_request->value, setup_request->index); + TRANSFER_END(request, ret); case USB_HUB_REQ_TYPE_SET_HUB_FEATURE: @@ -623,9 +663,10 @@ * features. It makes no sense to SET either. */ usb_log_error("Invalid HUB set feature request.\n"); - return ENOTSUP; + TRANSFER_END(request, ENOTSUP); + //TODO: Consider standard USB requests: REMOTE WAKEUP, ENDPOINT STALL default: usb_log_error("Invalid set feature request type: %d\n", setup_request->request_type); - return EINVAL; + TRANSFER_END(request, ENOTSUP); } } @@ -640,5 +681,5 @@ * @return error code */ -int clear_feature(const rh_t *instance, usb_transfer_batch_t *request) +void clear_feature(const rh_t *instance, usb_transfer_batch_t *request) { assert(instance); @@ -647,6 +688,4 @@ const usb_device_request_setup_packet_t *setup_request = (usb_device_request_setup_packet_t *) request->setup_buffer; - - request->transfered_size = 0; switch (setup_request->request_type) @@ -654,6 +693,7 @@ case USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE: usb_log_debug("USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE\n"); - return clear_feature_port(instance, + const int ret = clear_feature_port(instance, setup_request->value, setup_request->index); + TRANSFER_END(request, ret); case USB_HUB_REQ_TYPE_CLEAR_HUB_FEATURE: @@ -668,10 +708,11 @@ if (setup_request->value == USB_HUB_FEATURE_C_HUB_OVER_CURRENT) { instance->registers->rh_status = RHS_OCIC_FLAG; - TRANSFER_OK(0); + TRANSFER_END(request, EOK); } + //TODO: Consider standard USB requests: REMOTE WAKEUP, ENDPOINT STALL default: usb_log_error("Invalid clear feature request type: %d\n", setup_request->request_type); - return EINVAL; + TRANSFER_END(request, ENOTSUP); } } @@ -695,5 +736,5 @@ * @return error code */ -int control_request(rh_t *instance, usb_transfer_batch_t *request) +void control_request(rh_t *instance, usb_transfer_batch_t *request) { assert(instance); @@ -702,10 +743,10 @@ if (!request->setup_buffer) { usb_log_error("Root hub received empty transaction!"); - return EINVAL; + TRANSFER_END(request, EBADMEM); } if (sizeof(usb_device_request_setup_packet_t) > request->setup_size) { usb_log_error("Setup packet too small\n"); - return EOVERFLOW; + TRANSFER_END(request, EOVERFLOW); } @@ -718,45 +759,58 @@ case USB_DEVREQ_GET_STATUS: usb_log_debug("USB_DEVREQ_GET_STATUS\n"); - return get_status(instance, request); + get_status(instance, request); + break; case USB_DEVREQ_GET_DESCRIPTOR: usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n"); - return get_descriptor(instance, request); + get_descriptor(instance, request); + break; case USB_DEVREQ_GET_CONFIGURATION: usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n"); - if (request->buffer_size != 1) - return EINVAL; - request->buffer[0] = 1; - TRANSFER_OK(1); + if (request->buffer_size == 0) + TRANSFER_END(request, EOVERFLOW); + static const uint8_t config = 1; + TRANSFER_END_DATA(request, &config, sizeof(config)); case USB_DEVREQ_CLEAR_FEATURE: - usb_log_debug2("Processing request without " - "additional data\n"); - return clear_feature(instance, request); + usb_log_debug2("USB_DEVREQ_CLEAR_FEATURE\n"); + clear_feature(instance, request); + break; case USB_DEVREQ_SET_FEATURE: - usb_log_debug2("Processing request without " - "additional data\n"); - return set_feature(instance, request); + usb_log_debug2("USB_DEVREQ_SET_FEATURE\n"); + set_feature(instance, request); + break; case USB_DEVREQ_SET_ADDRESS: - usb_log_debug("USB_DEVREQ_SET_ADDRESS\n"); + usb_log_debug("USB_DEVREQ_SET_ADDRESS: %u\n", + setup_request->value); + if (uint16_usb2host(setup_request->value) > 127) + TRANSFER_END(request, EINVAL); + instance->address = setup_request->value; - TRANSFER_OK(0); + TRANSFER_END(request, EOK); case USB_DEVREQ_SET_CONFIGURATION: - usb_log_debug("USB_DEVREQ_SET_CONFIGURATION\n"); - /* We don't need to do anything */ - TRANSFER_OK(0); - - case USB_DEVREQ_SET_DESCRIPTOR: /* Not supported by OHCI RH */ + usb_log_debug("USB_DEVREQ_SET_CONFIGURATION: %u\n", + setup_request->value); + /* We have only one configuration, it's number is 1 */ + if (uint16_usb2host(setup_request->value) != 1) + TRANSFER_END(request, EINVAL); + TRANSFER_END(request, EOK); + + /* Both class specific and std is optional for hubs */ + case USB_DEVREQ_SET_DESCRIPTOR: + /* Hubs have only one interface GET/SET is not supported */ + case USB_DEVREQ_GET_INTERFACE: + case USB_DEVREQ_SET_INTERFACE: default: + /* Hub class GET_STATE(2) falls in here too. */ usb_log_error("Received unsupported request: %d.\n", setup_request->request); - return ENOTSUP; - } -} - + TRANSFER_END(request, ENOTSUP); + } +} /** * @} Index: uspace/drv/bus/usb/uhci/hc.c =================================================================== --- uspace/drv/bus/usb/uhci/hc.c (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/drv/bus/usb/uhci/hc.c (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -130,5 +130,5 @@ uhci_transfer_batch_t *batch = uhci_transfer_batch_from_link(item); - uhci_transfer_batch_call_dispose(batch); + uhci_transfer_batch_finish_dispose(batch); } } Index: uspace/drv/bus/usb/uhci/transfer_list.c =================================================================== --- uspace/drv/bus/usb/uhci/transfer_list.c (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/drv/bus/usb/uhci/transfer_list.c (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -184,6 +184,5 @@ uhci_transfer_batch_from_link(current); transfer_list_remove_batch(instance, batch); - batch->usb_batch->error = EINTR; - uhci_transfer_batch_call_dispose(batch); + uhci_transfer_batch_abort(batch); } fibril_mutex_unlock(&instance->guard); Index: uspace/drv/bus/usb/uhci/uhci_batch.c =================================================================== --- uspace/drv/bus/usb/uhci/uhci_batch.c (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/drv/bus/usb/uhci/uhci_batch.c (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -34,4 +34,5 @@ #include #include +#include #include @@ -45,4 +46,8 @@ #define DEFAULT_ERROR_COUNT 3 +/** Safely destructs uhci_transfer_batch_t structure. + * + * @param[in] uhci_batch Instance to destroy. + */ static void uhci_transfer_batch_dispose(uhci_transfer_batch_t *uhci_batch) { @@ -54,31 +59,23 @@ } /*----------------------------------------------------------------------------*/ -/** Safely destructs uhci_transfer_batch_t structure - * - * @param[in] uhci_batch Instance to destroy. - */ -void uhci_transfer_batch_call_dispose(uhci_transfer_batch_t *uhci_batch) +/** Finishes usb_transfer_batch and destroys the structure. + * + * @param[in] uhci_batch Instance to finish and destroy. + */ +void uhci_transfer_batch_finish_dispose(uhci_transfer_batch_t *uhci_batch) { assert(uhci_batch); assert(uhci_batch->usb_batch); usb_transfer_batch_finish(uhci_batch->usb_batch, - uhci_transfer_batch_data_buffer(uhci_batch), - uhci_batch->usb_batch->buffer_size); + uhci_transfer_batch_data_buffer(uhci_batch)); uhci_transfer_batch_dispose(uhci_batch); } /*----------------------------------------------------------------------------*/ +/** Transfer batch setup table. */ static void (*const batch_setup[])(uhci_transfer_batch_t*, usb_direction_t); /*----------------------------------------------------------------------------*/ /** Allocate memory and initialize internal data structure. * - * @param[in] fun DDF function to pass to callback. - * @param[in] ep Communication target - * @param[in] buffer Data source/destination. - * @param[in] buffer_size Size of the buffer. - * @param[in] setup_buffer Setup data source (if not NULL) - * @param[in] setup_size Size of setup_buffer (should be always 8) - * @param[in] func_in function to call on inbound transfer completion - * @param[in] func_out function to call on outbound transfer completion - * @param[in] arg additional parameter to func_in or func_out + * @param[in] usb_batch Pointer to generic USB batch structure. * @return Valid pointer if all structures were successfully created, * NULL otherwise. @@ -156,5 +153,5 @@ * is reached. */ -bool uhci_transfer_batch_is_complete(uhci_transfer_batch_t *uhci_batch) +bool uhci_transfer_batch_is_complete(const uhci_transfer_batch_t *uhci_batch) { assert(uhci_batch); @@ -200,4 +197,5 @@ } /*----------------------------------------------------------------------------*/ +/** Direction to pid conversion table */ static const usb_packet_id direction_pids[] = { [USB_DIRECTION_IN] = USB_PID_IN, @@ -237,6 +235,5 @@ while (remain_size > 0) { - const size_t packet_size = - (remain_size < mps) ? remain_size : mps; + const size_t packet_size = min(remain_size, mps); const td_t *next_td = (td + 1 < uhci_batch->td_count) @@ -309,6 +306,5 @@ while (remain_size > 0) { - const size_t packet_size = - (remain_size < mps) ? remain_size : mps; + const size_t packet_size = min(remain_size, mps); td_init( Index: uspace/drv/bus/usb/uhci/uhci_batch.h =================================================================== --- uspace/drv/bus/usb/uhci/uhci_batch.h (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/drv/bus/usb/uhci/uhci_batch.h (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -61,7 +61,11 @@ uhci_transfer_batch_t * uhci_transfer_batch_get(usb_transfer_batch_t *batch); -void uhci_transfer_batch_call_dispose(uhci_transfer_batch_t *uhci_batch); -bool uhci_transfer_batch_is_complete(uhci_transfer_batch_t *uhci_batch); +void uhci_transfer_batch_finish_dispose(uhci_transfer_batch_t *uhci_batch); +bool uhci_transfer_batch_is_complete(const uhci_transfer_batch_t *uhci_batch); +/** Get offset to setup buffer accessible to the HC hw. + * @param uhci_batch UHCI batch structure. + * @return Pointer to the setup buffer. + */ static inline void * uhci_transfer_batch_setup_buffer( const uhci_transfer_batch_t *uhci_batch) @@ -73,4 +77,8 @@ } /*----------------------------------------------------------------------------*/ +/** Get offset to data buffer accessible to the HC hw. + * @param uhci_batch UHCI batch structure. + * @return Pointer to the data buffer. + */ static inline void * uhci_transfer_batch_data_buffer( const uhci_transfer_batch_t *uhci_batch) @@ -82,4 +90,22 @@ } /*----------------------------------------------------------------------------*/ +/** Aborts the batch. + * Sets error to EINTR and size off transferd data to 0, before finishing the + * batch. + * @param uhci_batch Batch to abort. + */ +static inline void uhci_transfer_batch_abort(uhci_transfer_batch_t *uhci_batch) +{ + assert(uhci_batch); + assert(uhci_batch->usb_batch); + uhci_batch->usb_batch->error = EINTR; + uhci_batch->usb_batch->transfered_size = 0; + uhci_transfer_batch_finish_dispose(uhci_batch); +} +/*----------------------------------------------------------------------------*/ +/** Linked list conversion wrapper. + * @param l Linked list link. + * @return Pointer to the uhci batch structure. + */ static inline uhci_transfer_batch_t *uhci_transfer_batch_from_link(link_t *l) { Index: uspace/lib/usb/include/usb/classes/hub.h =================================================================== --- uspace/lib/usb/include/usb/classes/hub.h (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/lib/usb/include/usb/classes/hub.h (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -84,7 +84,8 @@ /** - * @brief usb hub descriptor - * - * For more information see Universal Serial Bus Specification Revision 1.1 chapter 11.16.2 + * @brief usb hub descriptor + * + * For more information see Universal Serial Bus Specification Revision 1.1 + * chapter 11.16.2 */ typedef struct usb_hub_descriptor_type { Index: uspace/lib/usb/src/usb.c =================================================================== --- uspace/lib/usb/src/usb.c (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/lib/usb/src/usb.c (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -39,27 +39,27 @@ static const char *str_speed[] = { - "low", - "full", - "high" + [USB_SPEED_LOW] = "low", + [USB_SPEED_FULL] = "full", + [USB_SPEED_HIGH] = "high", }; static const char *str_transfer_type[] = { - "control", - "isochronous", - "bulk", - "interrupt" + [USB_TRANSFER_CONTROL] = "control", + [USB_TRANSFER_ISOCHRONOUS] = "isochronous", + [USB_TRANSFER_BULK] = "bulk", + [USB_TRANSFER_INTERRUPT] = "interrupt", }; static const char *str_transfer_type_short[] = { - "ctrl", - "iso", - "bulk", - "intr" + [USB_TRANSFER_CONTROL] = "ctrl", + [USB_TRANSFER_ISOCHRONOUS] = "iso", + [USB_TRANSFER_BULK] = "bulk", + [USB_TRANSFER_INTERRUPT] = "intr", }; static const char *str_direction[] = { - "in", - "out", - "both" + [USB_DIRECTION_IN] = "in", + [USB_DIRECTION_OUT] = "out", + [USB_DIRECTION_BOTH] = "both", }; Index: uspace/lib/usbdev/include/usb/dev/request.h =================================================================== --- uspace/lib/usbdev/include/usb/dev/request.h (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/lib/usbdev/include/usb/dev/request.h (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -83,4 +83,10 @@ uint8_t request_type; #define SETUP_REQUEST_TYPE_DEVICE_TO_HOST (1 << 7) +#define SETUP_REQUEST_TYPE_GET_TYPE(rt) ((rt >> 5) & 0x3) +#define SETUP_REQUEST_TYPE_GET_RECIPIENT(rec) (rec & 0x1f) +#define SETUP_REQUEST_TO_HOST(type, recipient) \ + (uint8_t)((1 << 7) | ((type & 0x3) << 5) | (recipient & 0x1f)) +#define SETUP_REQUEST_TO_DEVICE(type, recipient) \ + (uint8_t)(((type & 0x3) << 5) | (recipient & 0x1f)) /** Request identification. */ Index: uspace/lib/usbhost/include/usb/host/usb_transfer_batch.h =================================================================== --- uspace/lib/usbhost/include/usb/host/usb_transfer_batch.h (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/lib/usbhost/include/usb/host/usb_transfer_batch.h (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -106,20 +106,19 @@ void usb_transfer_batch_destroy(const usb_transfer_batch_t *instance); -void usb_transfer_batch_finish(const usb_transfer_batch_t *instance, - const void* data, size_t size); +void usb_transfer_batch_finish_error(const usb_transfer_batch_t *instance, + const void* data, size_t size, int error); /*----------------------------------------------------------------------------*/ -/** Override error value and finishes transfer. +/** Finish batch using stored error value. * * @param[in] instance Batch structure to use. * @param[in] data Data to copy to the output buffer. * @param[in] size Size of @p data. - * @param[in] error Set batch status to this error value. */ -static inline void usb_transfer_batch_finish_error( - usb_transfer_batch_t *instance, const void* data, size_t size, int error) +static inline void usb_transfer_batch_finish( + const usb_transfer_batch_t *instance, const void* data) { assert(instance); - instance->error = error; - usb_transfer_batch_finish(instance, data, size); + usb_transfer_batch_finish_error( + instance, data, instance->transfered_size, instance->error); } /*----------------------------------------------------------------------------*/ Index: uspace/lib/usbhost/src/usb_transfer_batch.c =================================================================== --- uspace/lib/usbhost/src/usb_transfer_batch.c (revision c40f385935fd4dfd3533aaf80ac29399a0203e2d) +++ uspace/lib/usbhost/src/usb_transfer_batch.c (revision 89128f37525649ee8a7c2d6155cdc0a5b27244e9) @@ -33,5 +33,5 @@ */ #include -#include +#include #include @@ -121,7 +121,8 @@ * @param[in] data Data to copy to the output buffer. * @param[in] size Size of @p data. + * @param[in] error Error value to use. */ -void usb_transfer_batch_finish( - const usb_transfer_batch_t *instance, const void *data, size_t size) +void usb_transfer_batch_finish_error(const usb_transfer_batch_t *instance, + const void *data, size_t size, int error) { assert(instance); @@ -133,5 +134,5 @@ /* Check for commands that reset toggle bit */ if (instance->ep->transfer_type == USB_TRANSFER_CONTROL - && instance->error == EOK) { + && error == EOK) { const usb_target_t target = {{ instance->ep->address, instance->ep->endpoint }}; @@ -139,17 +140,15 @@ instance->setup_buffer); } - instance->callback_out(instance->fun, - instance->error, instance->arg); + instance->callback_out(instance->fun, error, instance->arg); } if (instance->callback_in) { /* We care about the data and there are some to copy */ + const size_t safe_size = min(size, instance->buffer_size); if (data) { - const size_t min_size = size < instance->buffer_size - ? size : instance->buffer_size; - memcpy(instance->buffer, data, min_size); + memcpy(instance->buffer, data, safe_size); } - instance->callback_in(instance->fun, instance->error, - instance->transfered_size, instance->arg); + instance->callback_in(instance->fun, error, + safe_size, instance->arg); } }