Index: uspace/lib/usb/include/usb/classes/hub.h =================================================================== --- uspace/lib/usb/include/usb/classes/hub.h (revision e4dbfda81ffba0222ededb046f47d6be4a1ebfd4) +++ uspace/lib/usb/include/usb/classes/hub.h (revision 8e423a2ded91473d6ca9d0ac5834bfcd9c00294a) @@ -36,14 +36,7 @@ #define LIBUSB_HUB_H_ -/** Hub class request. */ -typedef enum { - USB_HUB_REQUEST_GET_STATUS = 0, - USB_HUB_REQUEST_CLEAR_FEATURE = 1, - USB_HUB_REQUEST_GET_STATE = 2, - USB_HUB_REQUEST_SET_FEATURE = 3, - USB_HUB_REQUEST_GET_DESCRIPTOR = 6, - USB_HUB_REQUEST_SET_DESCRIPTOR = 7, - /* USB_HUB_REQUEST_ = , */ -} usb_hub_class_request_t; +#include +#include + /** Hub class feature selector. @@ -69,4 +62,167 @@ } usb_hub_class_feature_t; + +/** + * @brief usb hub descriptor + * + * For more information see Universal Serial Bus Specification Revision 1.1 chapter 11.16.2 + */ +typedef struct hub_descriptor_type{ + /** Number of bytes in this descriptor, including this byte */ + //uint8_t bDescLength; + + /** Descriptor Type, value: 29H for hub descriptor */ + //uint8_t bDescriptorType; + + /** Number of downstream ports that this hub supports */ + uint8_t ports_count; + + /** + D1...D0: Logical Power Switching Mode + 00: Ganged power switching (all ports’ power at + once) + 01: Individual port power switching + 1X: Reserved. Used only on 1.0 compliant hubs + that implement no power switching. + D2: Identifies a Compound Device + 0: Hub is not part of a compound device + 1: Hub is part of a compound device + D4...D3: Over-current Protection Mode + 00: Global Over-current Protection. The hub + reports over-current as a summation of all + ports’ current draw, without a breakdown of + individual port over-current status. + 01: Individual Port Over-current Protection. The + hub reports over-current on a per-port basis. + Each port has an over-current indicator. + 1X: No Over-current Protection. This option is + allowed only for bus-powered hubs that do not + implement over-current protection. + D15...D5: + Reserved + */ + uint16_t hub_characteristics; + + /** + Time (in 2ms intervals) from the time the power-on + sequence begins on a port until power is good on that + port. The USB System Software uses this value to + determine how long to wait before accessing a + powered-on port. + */ + uint8_t pwr_on_2_good_time; + + /** + Maximum current requirements of the Hub Controller + electronics in mA. + */ + uint8_t current_requirement; + + /** + Indicates if a port has a removable device attached. + This field is reported on byte-granularity. Within a + byte, if no port exists for a given location, the field + representing the port characteristics returns 0. + Bit value definition: + 0B - Device is removable + 1B - Device is non-removable + This is a bitmap corresponding to the individual ports + on the hub: + Bit 0: Reserved for future use + Bit 1: Port 1 + Bit 2: Port 2 + .... + Bit n: Port n (implementation-dependent, up to a + maximum of 255 ports). + */ + uint8_t * devices_removable; + + /** + This field exists for reasons of compatibility with + software written for 1.0 compliant devices. All bits in + this field should be set to 1B. This field has one bit for + each port on the hub with additional pad bits, if + necessary, to make the number of bits in the field an + integer multiple of 8. + */ + //uint8_t * port_pwr_ctrl_mask; +} usb_hub_descriptor_t; + + + +/** @brief usb hub specific request types. + * + * For more information see Universal Serial Bus Specification Revision 1.1 chapter 11.16.2 + */ +typedef enum { + /** This request resets a value reported in the hub status. */ + USB_HUB_REQ_TYPE_CLEAR_HUB_FEATURE = 0x20, + /** This request resets a value reported in the port status. */ + USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE = 0x23, + /** This is an optional per-port diagnostic request that returns the bus state value, as sampled at the last EOF2 point. */ + USB_HUB_REQ_TYPE_GET_STATE = 0xA3, + /** This request returns the hub descriptor. */ + USB_HUB_REQ_TYPE_GET_DESCRIPTOR = 0xA0, + /** This request returns the current hub status and the states that have changed since the previous acknowledgment. */ + USB_HUB_REQ_TYPE_GET_HUB_STATUS = 0xA0, + /** This request returns the current port status and the current value of the port status change bits. */ + USB_HUB_REQ_TYPE_GET_PORT_STATUS = 0xA3, + /** This request overwrites the hub descriptor. */ + USB_HUB_REQ_TYPE_SET_DESCRIPTOR = 0x20, + /** This request sets a value reported in the hub status. */ + USB_HUB_REQ_TYPE_SET_HUB_FEATURE = 0x20, + /** This request sets a value reported in the port status. */ + USB_HUB_REQ_TYPE_SET_PORT_FEATURE = 0x23 +} usb_hub_bm_request_type_t; + +/** @brief hub class request codes*/ +typedef enum { + /** */ + USB_HUB_REQUEST_GET_STATUS = 0, + /** */ + USB_HUB_REQUEST_CLEAR_FEATURE = 1, + /** */ + USB_HUB_REQUEST_GET_STATE = 2, + /** */ + USB_HUB_REQUEST_SET_FEATURE = 3, + /** */ + USB_HUB_REQUEST_GET_DESCRIPTOR = 6, + /** */ + USB_HUB_REQUEST_SET_DESCRIPTOR = 7 +} usb_hub_request_t; + +/** + * Maximum size of usb hub descriptor in bytes + */ +extern size_t USB_HUB_MAX_DESCRIPTOR_SIZE; + +/** + * @brief create uint8_t array with serialized descriptor + * + * @param descriptor + */ +void * usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor); + +/** + * @brief create deserialized desriptor structure out of serialized descriptor + * + * The serialized descriptor must be proper usb hub descriptor, otherwise an eerror might occur. + * + * @param sdescriptor serialized descriptor + */ +usb_hub_descriptor_t * usb_deserialize_hub_desriptor(void * sdescriptor); + +/** + * @brief create hub structure instance + * + * @param device + * @return + */ +usb_hcd_hub_info_t * usb_create_hub_info(device_t * device); + + + + + #endif /** Index: uspace/lib/usb/src/hcdhubd.c =================================================================== --- uspace/lib/usb/src/hcdhubd.c (revision e4dbfda81ffba0222ededb046f47d6be4a1ebfd4) +++ uspace/lib/usb/src/hcdhubd.c (revision 8e423a2ded91473d6ca9d0ac5834bfcd9c00294a) @@ -36,9 +36,16 @@ #include #include +#include #include #include #include +#include #define USB_HUB_DEVICE_NAME "usbhub" + +#define USB_KBD_DEVICE_NAME "hid" + + + /** List of handled host controllers. */ @@ -57,13 +64,96 @@ }; +size_t USB_HUB_MAX_DESCRIPTOR_SIZE = 71; + +uint8_t USB_HUB_DESCRIPTOR_TYPE = 0x29; + +//********************************************* +// +// various utils +// +//********************************************* + +void * usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor) { + //base size + size_t size = 7; + //variable size according to port count + size_t var_size = descriptor->ports_count / 8 + ((descriptor->ports_count % 8 > 0) ? 1 : 0); + size += 2 * var_size; + uint8_t * result = (uint8_t*) malloc(size); + //size + result[0] = size; + //descriptor type + result[1] = USB_DESCTYPE_HUB; + result[2] = descriptor->ports_count; + /// @fixme handling of endianness?? + result[3] = descriptor->hub_characteristics / 256; + result[4] = descriptor->hub_characteristics % 256; + result[5] = descriptor->pwr_on_2_good_time; + result[6] = descriptor->current_requirement; + + size_t i; + for (i = 0; i < var_size; ++i) { + result[7 + i] = descriptor->devices_removable[i]; + } + for (i = 0; i < var_size; ++i) { + result[7 + var_size + i] = 255; + } + return result; +} + +usb_hub_descriptor_t * usb_deserialize_hub_desriptor(void * serialized_descriptor) { + uint8_t * sdescriptor = (uint8_t*) serialized_descriptor; + if (sdescriptor[1] != USB_DESCTYPE_HUB) return NULL; + usb_hub_descriptor_t * result = (usb_hub_descriptor_t*) malloc(sizeof (usb_hub_descriptor_t)); + //uint8_t size = sdescriptor[0]; + result->ports_count = sdescriptor[2]; + /// @fixme handling of endianness?? + result->hub_characteristics = sdescriptor[4] + 256 * sdescriptor[3]; + result->pwr_on_2_good_time = sdescriptor[5]; + result->current_requirement = sdescriptor[6]; + size_t var_size = result->ports_count / 8 + ((result->ports_count % 8 > 0) ? 1 : 0); + result->devices_removable = (uint8_t*) malloc(var_size); + + size_t i; + for (i = 0; i < var_size; ++i) { + result->devices_removable[i] = sdescriptor[7 + i]; + } + return result; +} + + +//********************************************* +// +// hub driver code +// +//********************************************* + static void set_hub_address(usb_hc_device_t *hc, usb_address_t address); +usb_hcd_hub_info_t * usb_create_hub_info(device_t * device) { + usb_hcd_hub_info_t* result = (usb_hcd_hub_info_t*) malloc(sizeof (usb_hcd_hub_info_t)); + //get parent device + /// @TODO this code is not correct + device_t * my_hcd = device; + while (my_hcd->parent) + my_hcd = my_hcd->parent; + //dev-> + printf("%s: owner hcd found: %s\n", hc_driver->name, my_hcd->name); + //we add the hub into the first hc + //link_t *link_hc = hc_list.next; + //usb_hc_device_t *hc = list_get_instance(link_hc, + // usb_hc_device_t, link); + //must get generic device info + + + return result; +} + /** Callback when new device is detected and must be handled by this driver. * * @param dev New device. - * @return Error code. - */ -static int add_device(device_t *dev) -{ + * @return Error code.hub added, hurrah!\n" + */ +static int add_device(device_t *dev) { /* * FIXME: use some magic to determine whether hub or another HC @@ -77,5 +167,5 @@ * We are the HC itself. */ - usb_hc_device_t *hc_dev = malloc(sizeof(usb_hc_device_t)); + usb_hc_device_t *hc_dev = malloc(sizeof (usb_hc_device_t)); list_initialize(&hc_dev->link); hc_dev->transfer_ops = NULL; @@ -99,5 +189,47 @@ list_append(&hc_dev->link, &hc_list); + //add keyboard + /// @TODO this is not correct code + + /* + * Announce presence of child device. + */ + device_t *kbd = NULL; + match_id_t *match_id = NULL; + + kbd = create_device(); + if (kbd == NULL) { + printf("ERROR: enomem\n"); + } + kbd->name = USB_KBD_DEVICE_NAME; + + match_id = create_match_id(); + if (match_id == NULL) { + printf("ERROR: enomem\n"); + } + + char *id; + rc = asprintf(&id, USB_KBD_DEVICE_NAME); + if (rc <= 0) { + printf("ERROR: enomem\n"); + return rc; + } + + match_id->id = id; + match_id->score = 30; + + add_match_id(&kbd->match_ids, match_id); + + rc = child_device_register(kbd, dev); + if (rc != EOK) { + printf("ERROR: cannot register kbd\n"); + return rc; + } + + printf("%s: registered root hub\n", dev->name); return EOK; + + + } else { usb_hc_device_t *hc = list_get_instance(hc_list.next, usb_hc_device_t, link); @@ -109,6 +241,30 @@ * connected devices. */ - - return ENOTSUP; + //insert hub into list + //find owner hcd + device_t * my_hcd = dev; + while (my_hcd->parent) + my_hcd = my_hcd->parent; + //dev-> + printf("%s: owner hcd found: %s\n", hc_driver->name, my_hcd->name); + my_hcd = dev; + while (my_hcd->parent) + my_hcd = my_hcd->parent; + //dev-> + + printf("%s: owner hcd found: %s\n", hc_driver->name, my_hcd->name); + + //create the hub structure + usb_hcd_hub_info_t * hub_info = usb_create_hub_info(dev); + + + //append into the list + //we add the hub into the first hc + list_append(&hub_info->link, &hc->hubs); + + + + return EOK; + //return ENOTSUP; } } @@ -123,6 +279,5 @@ * @param address New hub address. */ -static void set_hub_address(usb_hc_device_t *hc, usb_address_t address) -{ +static void set_hub_address(usb_hc_device_t *hc, usb_address_t address) { printf("%s: setting hub address to %d\n", hc->generic->name, address); usb_target_t target = {0, 0}; @@ -139,5 +294,5 @@ rc = usb_hc_async_control_write_setup(hc, target, - &setup_packet, sizeof(setup_packet), &handle); + &setup_packet, sizeof (setup_packet), &handle); if (rc != EOK) { return; @@ -164,6 +319,5 @@ /** Check changes on all known hubs. */ -static void check_hub_changes(void) -{ +static void check_hub_changes(void) { /* * Iterate through all HCs. @@ -171,8 +325,8 @@ link_t *link_hc; for (link_hc = hc_list.next; - link_hc != &hc_list; - link_hc = link_hc->next) { + link_hc != &hc_list; + link_hc = link_hc->next) { usb_hc_device_t *hc = list_get_instance(link_hc, - usb_hc_device_t, link); + usb_hc_device_t, link); /* * Iterate through all their hubs. @@ -180,8 +334,8 @@ link_t *link_hub; for (link_hub = hc->hubs.next; - link_hub != &hc->hubs; - link_hub = link_hub->next) { + link_hub != &hc->hubs; + link_hub = link_hub->next) { usb_hcd_hub_info_t *hub = list_get_instance(link_hub, - usb_hcd_hub_info_t, link); + usb_hcd_hub_info_t, link); /* @@ -205,6 +359,6 @@ */ usb_hc_async_interrupt_in(hc, target, - change_bitmap, byte_length, &actual_size, - &handle); + change_bitmap, byte_length, &actual_size, + &handle); usb_hc_async_wait_for(handle); @@ -234,6 +388,5 @@ * @return Error code. */ -int usb_hcd_main(usb_hc_driver_t *hc) -{ +int usb_hcd_main(usb_hc_driver_t *hc) { hc_driver = hc; hc_driver_generic.name = hc->name;