Changeset c6cb76d in mainline


Ignore:
Timestamp:
2011-04-08T20:19:48Z (13 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
297341b
Parents:
7dfc06fa (diff), 61727bf (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge development/ changes

Files:
17 added
23 edited

Legend:

Unmodified
Added
Removed

  • boot/arch/amd64/Makefile.inc

    r7dfc06fa rc6cb76d  
    5050        usbhub \
    5151        usbkbd \
     52        usbhid \
    5253        usbmid \
    5354        usbmouse \

  • uspace/Makefile

    r7dfc06fa rc6cb76d  
    123123                drv/usbflbk \
    124124                drv/usbkbd \
     125                drv/usbhid \
    125126                drv/usbhub \
    126127                drv/usbmid \
    … …  
    143144                drv/usbflbk \
    144145                drv/usbkbd \
     146                drv/usbhid \
    145147                drv/usbhub \
    146148                drv/usbmid \

  • uspace/drv/ohci/root_hub.c

    r7dfc06fa rc6cb76d  
    4747 *      standart device descriptor for ohci root hub
    4848 */
    49 static const usb_standard_device_descriptor_t ohci_rh_device_descriptor =
    50 {
    51                 .configuration_count = 1,
    52                 .descriptor_type = USB_DESCTYPE_DEVICE,
    53                 .device_class = USB_CLASS_HUB,
    54                 .device_protocol = 0,
    55                 .device_subclass = 0,
    56                 .device_version = 0,
    57                 .length = sizeof(usb_standard_device_descriptor_t),
    58                 /// \TODO this value is guessed
    59                 .max_packet_size = 8,
    60                 .vendor_id = 0x16db,
    61                 .product_id = 0x0001,
    62                 /// \TODO these values migt be different
    63                 .str_serial_number = 0,
    64                 .usb_spec_version = 0x110,
     49static const usb_standard_device_descriptor_t ohci_rh_device_descriptor = {
     50        .configuration_count = 1,
     51        .descriptor_type = USB_DESCTYPE_DEVICE,
     52        .device_class = USB_CLASS_HUB,
     53        .device_protocol = 0,
     54        .device_subclass = 0,
     55        .device_version = 0,
     56        .length = sizeof (usb_standard_device_descriptor_t),
     57        /// \TODO this value is guessed
     58        .max_packet_size = 8,
     59        .vendor_id = 0x16db,
     60        .product_id = 0x0001,
     61        /// \TODO these values migt be different
     62        .str_serial_number = 0,
     63        .usb_spec_version = 0x110,
    6564};
    6665
    … …  
    6968 * for ohci root hubs
    7069 */
    71 static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor =
    72 {
     70static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor = {
    7371        /// \TODO some values are default or guessed
    74         .attributes = 1<<7,
     72        .attributes = 1 << 7,
    7573        .configuration_number = 1,
    7674        .descriptor_type = USB_DESCTYPE_CONFIGURATION,
    7775        .interface_count = 1,
    78         .length = sizeof(usb_standard_configuration_descriptor_t),
     76        .length = sizeof (usb_standard_configuration_descriptor_t),
    7977        .max_power = 100,
    8078        .str_configuration = 0,
    … …  
    8482 * standart ohci root hub interface descriptor
    8583 */
    86 static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor =
    87 {
     84static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor = {
    8885        .alternate_setting = 0,
    8986        .descriptor_type = USB_DESCTYPE_INTERFACE,
    … …  
    9491        .interface_protocol = 0,
    9592        .interface_subclass = 0,
    96         .length = sizeof(usb_standard_interface_descriptor_t),
     93        .length = sizeof (usb_standard_interface_descriptor_t),
    9794        .str_interface = 0,
    9895};
    … …  
    10198 * standart ohci root hub endpoint descriptor
    10299 */
    103 static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor =
    104 {
     100static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor = {
    105101        .attributes = USB_TRANSFER_INTERRUPT,
    106102        .descriptor_type = USB_DESCTYPE_ENDPOINT,
    107         .endpoint_address = 1 + (1<<7),
    108         .length = sizeof(usb_standard_endpoint_descriptor_t),
     103        .endpoint_address = 1 + (1 << 7),
     104        .length = sizeof (usb_standard_endpoint_descriptor_t),
    109105        .max_packet_size = 8,
    110106        .poll_interval = 255,
    … …  
    112108
    113109static const uint32_t hub_clear_feature_valid_mask =
    114         (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) +
    115         (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
     110        (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) |
     111(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
    116112
    117113static const uint32_t hub_clear_feature_by_writing_one_mask =
    … …  
    121117        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
    122118
    123        
     119
    124120static const uint32_t hub_set_feature_direct_mask =
    125121        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
    126122
    127123static const uint32_t port_set_feature_valid_mask =
    128         (1 << USB_HUB_FEATURE_PORT_ENABLE) +
    129         (1 << USB_HUB_FEATURE_PORT_SUSPEND) +
    130         (1 << USB_HUB_FEATURE_PORT_RESET) +
    131         (1 << USB_HUB_FEATURE_PORT_POWER);
     124        (1 << USB_HUB_FEATURE_PORT_ENABLE) |
     125(1 << USB_HUB_FEATURE_PORT_SUSPEND) |
     126(1 << USB_HUB_FEATURE_PORT_RESET) |
     127(1 << USB_HUB_FEATURE_PORT_POWER);
    132128
    133129static const uint32_t port_clear_feature_valid_mask =
    134         (1 << USB_HUB_FEATURE_PORT_CONNECTION) +
    135         (1 << USB_HUB_FEATURE_PORT_SUSPEND) +
    136         (1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) +
    137         (1 << USB_HUB_FEATURE_PORT_POWER) +
    138         (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) +
    139         (1 << USB_HUB_FEATURE_C_PORT_ENABLE) +
    140         (1 << USB_HUB_FEATURE_C_PORT_SUSPEND) +
    141         (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) +
    142         (1 << USB_HUB_FEATURE_C_PORT_RESET);
    143 //note that USB_HUB_FEATURE_PORT_POWER bit is translated into USB_HUB_FEATURE_PORT_LOW_SPEED
    144 
    145 
    146 
     130        (1 << USB_HUB_FEATURE_PORT_CONNECTION) |
     131(1 << USB_HUB_FEATURE_PORT_SUSPEND) |
     132(1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) |
     133(1 << USB_HUB_FEATURE_PORT_POWER) |
     134(1 << USB_HUB_FEATURE_C_PORT_CONNECTION) |
     135(1 << USB_HUB_FEATURE_C_PORT_ENABLE) |
     136(1 << USB_HUB_FEATURE_C_PORT_SUSPEND) |
     137(1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
     138(1 << USB_HUB_FEATURE_C_PORT_RESET);
     139//note that USB_HUB_FEATURE_PORT_POWER bit is translated into
     140//USB_HUB_FEATURE_PORT_LOW_SPEED
     141
     142static const uint32_t port_status_change_mask =
     143(1<< USB_HUB_FEATURE_C_PORT_CONNECTION) |
     144(1<< USB_HUB_FEATURE_C_PORT_ENABLE) |
     145(1<< USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
     146(1<< USB_HUB_FEATURE_C_PORT_RESET) |
     147(1<< USB_HUB_FEATURE_C_PORT_SUSPEND);
     148
     149
     150static void usb_create_serialized_hub_descriptor(rh_t *instance,
     151        uint8_t ** out_result,
     152        size_t * out_size);
     153
     154static void rh_init_descriptors(rh_t *instance);
     155
     156static int process_get_port_status_request(rh_t *instance, uint16_t port,
     157        usb_transfer_batch_t * request);
     158
     159static int process_get_hub_status_request(rh_t *instance,
     160        usb_transfer_batch_t * request);
     161
     162static int process_get_status_request(rh_t *instance,
     163        usb_transfer_batch_t * request);
     164
     165static void create_interrupt_mask(rh_t *instance, void ** buffer,
     166        size_t * buffer_size);
     167
     168static int process_get_descriptor_request(rh_t *instance,
     169        usb_transfer_batch_t *request);
     170
     171static int process_get_configuration_request(rh_t *instance,
     172        usb_transfer_batch_t *request);
     173
     174static int process_hub_feature_set_request(rh_t *instance, uint16_t feature);
     175
     176static int process_hub_feature_clear_request(rh_t *instance,
     177        uint16_t feature);
     178
     179static int process_port_feature_set_request(rh_t *instance,
     180        uint16_t feature, uint16_t port);
     181
     182static int process_port_feature_clear_request(rh_t *instance,
     183        uint16_t feature, uint16_t port);
     184
     185static int process_address_set_request(rh_t *instance,
     186        uint16_t address);
     187
     188static int process_request_with_output(rh_t *instance,
     189        usb_transfer_batch_t *request);
     190
     191static int process_request_with_input(rh_t *instance,
     192        usb_transfer_batch_t *request);
     193
     194static int process_request_without_data(rh_t *instance,
     195        usb_transfer_batch_t *request);
     196
     197static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request);
     198
     199
     200
     201
     202
     203/** Root hub initialization
     204 * @return Error code.
     205 */
     206int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs) {
     207        assert(instance);
     208        //instance->address = -1;
     209        instance->registers = regs;
     210        instance->device = dev;
     211        instance->port_count = instance->registers->rh_desc_a & 0xff;
     212        rh_init_descriptors(instance);
     213        // set port power mode to no-power-switching
     214        instance->registers->rh_desc_a =
     215                instance->registers->rh_desc_a | (1<<9);
     216
     217        usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
     218
     219        //start generic usb hub driver
     220
     221        /* TODO: implement */
     222        return EOK;
     223}
     224/*----------------------------------------------------------------------------*/
     225
     226/**
     227 * process root hub request
     228 *
     229 * @param instance root hub instance
     230 * @param request structure containing both request and response information
     231 * @return error code
     232 */
     233int rh_request(rh_t *instance, usb_transfer_batch_t *request) {
     234        assert(instance);
     235        assert(request);
     236        int opResult;
     237        if (request->transfer_type == USB_TRANSFER_CONTROL) {
     238                usb_log_info("Root hub got CONTROL packet\n");
     239                opResult = process_ctrl_request(instance, request);
     240        } else if (request->transfer_type == USB_TRANSFER_INTERRUPT) {
     241                usb_log_info("Root hub got INTERRUPT packet\n");
     242                void * buffer;
     243                create_interrupt_mask(instance, &buffer,
     244                        &(request->transfered_size));
     245                memcpy(request->transport_buffer, buffer,
     246                        request->transfered_size);
     247                opResult = EOK;
     248        } else {
     249                opResult = EINVAL;
     250        }
     251        usb_transfer_batch_finish_error(request, opResult);
     252        return EOK;
     253}
     254
     255/*----------------------------------------------------------------------------*/
     256
     257
     258void rh_interrupt(rh_t *instance) {
     259        usb_log_info("Whoa whoa wait, I`m not supposed to receive any "
     260                "interrupts, am I?\n");
     261        /* TODO: implement? */
     262}
     263/*----------------------------------------------------------------------------*/
    147264
    148265/**
    … …  
    157274 */
    158275static void usb_create_serialized_hub_descriptor(rh_t *instance,
    159                 uint8_t ** out_result,
    160                 size_t * out_size) {
     276        uint8_t ** out_result,
     277        size_t * out_size) {
    161278        //base size
    162279        size_t size = 7;
    163280        //variable size according to port count
    164281        size_t var_size = instance->port_count / 8 +
    165                         ((instance->port_count % 8 > 0) ? 1 : 0);
     282                ((instance->port_count % 8 > 0) ? 1 : 0);
    166283        size += 2 * var_size;
    167284        uint8_t * result = (uint8_t*) malloc(size);
    168         bzero(result,size);
     285        bzero(result, size);
    169286        //size
    170287        result[0] = size;
    … …  
    174291        uint32_t hub_desc_reg = instance->registers->rh_desc_a;
    175292        result[3] =
    176                         ((hub_desc_reg >> 8) %2) +
    177                         (((hub_desc_reg >> 9) %2) << 1) +
    178                         (((hub_desc_reg >> 10) %2) << 2) +
    179                         (((hub_desc_reg >> 11) %2) << 3) +
    180                         (((hub_desc_reg >> 12) %2) << 4);
     293                ((hub_desc_reg >> 8) % 2) +
     294                (((hub_desc_reg >> 9) % 2) << 1) +
     295                (((hub_desc_reg >> 10) % 2) << 2) +
     296                (((hub_desc_reg >> 11) % 2) << 3) +
     297                (((hub_desc_reg >> 12) % 2) << 4);
    181298        result[4] = 0;
    182299        result[5] = /*descriptor->pwr_on_2_good_time*/ 50;
    … …  
    185302        int port;
    186303        for (port = 1; port <= instance->port_count; ++port) {
    187                 result[7 + port/8] +=
    188                                 ((instance->registers->rh_desc_b >> port)%2) << (port%8);
     304                uint8_t is_non_removable =
     305                        instance->registers->rh_desc_b >> port % 2;
     306                result[7 + port / 8] +=
     307                        is_non_removable << (port % 8);
    189308        }
    190309        size_t i;
    … …  
    195314        (*out_size) = size;
    196315}
    197 
     316/*----------------------------------------------------------------------------*/
    198317
    199318/** initialize hub descriptors
    … …  
    203322 * @instance root hub instance
    204323 */
    205 static void rh_init_descriptors(rh_t *instance){
     324static void rh_init_descriptors(rh_t *instance) {
    206325        memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor,
    207                 sizeof(ohci_rh_device_descriptor)
    208         );
     326                sizeof (ohci_rh_device_descriptor)
     327                );
    209328        usb_standard_configuration_descriptor_t descriptor;
    210         memcpy(&descriptor,&ohci_rh_conf_descriptor,
    211                         sizeof(ohci_rh_conf_descriptor));
     329        memcpy(&descriptor, &ohci_rh_conf_descriptor,
     330                sizeof (ohci_rh_conf_descriptor));
    212331        uint8_t * hub_descriptor;
    213332        size_t hub_desc_size;
    214333        usb_create_serialized_hub_descriptor(instance, &hub_descriptor,
    215                         &hub_desc_size);
     334                &hub_desc_size);
    216335
    217336        descriptor.total_length =
    218                         sizeof(usb_standard_configuration_descriptor_t)+
    219                         sizeof(usb_standard_endpoint_descriptor_t)+
    220                         sizeof(usb_standard_interface_descriptor_t)+
    221                         hub_desc_size;
    222        
     337                sizeof (usb_standard_configuration_descriptor_t) +
     338                sizeof (usb_standard_endpoint_descriptor_t) +
     339                sizeof (usb_standard_interface_descriptor_t) +
     340                hub_desc_size;
     341
    223342        uint8_t * full_config_descriptor =
    224                         (uint8_t*) malloc(descriptor.total_length);
    225         memcpy(full_config_descriptor, &descriptor, sizeof(descriptor));
    226         memcpy(full_config_descriptor + sizeof(descriptor),
    227                         &ohci_rh_iface_descriptor, sizeof(ohci_rh_iface_descriptor));
    228         memcpy(full_config_descriptor + sizeof(descriptor) +
    229                                 sizeof(ohci_rh_iface_descriptor),
    230                         &ohci_rh_ep_descriptor, sizeof(ohci_rh_ep_descriptor));
    231         memcpy(full_config_descriptor + sizeof(descriptor) +
    232                                 sizeof(ohci_rh_iface_descriptor) +
    233                                 sizeof(ohci_rh_ep_descriptor),
    234                         hub_descriptor, hub_desc_size);
    235        
     343                (uint8_t*) malloc(descriptor.total_length);
     344        memcpy(full_config_descriptor, &descriptor, sizeof (descriptor));
     345        memcpy(full_config_descriptor + sizeof (descriptor),
     346                &ohci_rh_iface_descriptor, sizeof (ohci_rh_iface_descriptor));
     347        memcpy(full_config_descriptor + sizeof (descriptor) +
     348                sizeof (ohci_rh_iface_descriptor),
     349                &ohci_rh_ep_descriptor, sizeof (ohci_rh_ep_descriptor));
     350        memcpy(full_config_descriptor + sizeof (descriptor) +
     351                sizeof (ohci_rh_iface_descriptor) +
     352                sizeof (ohci_rh_ep_descriptor),
     353                hub_descriptor, hub_desc_size);
     354
    236355        instance->descriptors.configuration = full_config_descriptor;
    237356        instance->descriptors.configuration_size = descriptor.total_length;
    238357}
    239 
    240 /** Root hub initialization
    241  * @return Error code.
    242  */
    243 int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs)
    244 {
    245         assert(instance);
    246         instance->address = -1;
    247         instance->registers = regs;
    248         instance->device = dev;
    249         instance->port_count = instance->registers->rh_desc_a & 0xff;
    250         rh_init_descriptors(instance);
    251         /// \TODO set port power mode
    252 
    253 
    254         usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
    255 
    256         //start generic usb hub driver
    257        
    258         /* TODO: implement */
    259         return EOK;
    260 }
    261358/*----------------------------------------------------------------------------*/
    262359
    … …  
    272369 */
    273370static int process_get_port_status_request(rh_t *instance, uint16_t port,
    274                 usb_transfer_batch_t * request){
    275         if(port<1 || port>instance->port_count)
    276                 return EINVAL;
    277         uint32_t * uint32_buffer = (uint32_t*)request->transport_buffer;
     371        usb_transfer_batch_t * request) {
     372        if (port < 1 || port > instance->port_count)
     373                return EINVAL;
     374        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
    278375        request->transfered_size = 4;
    279         uint32_buffer[0] = instance->registers->rh_port_status[port -1];
    280         return EOK;
    281 }
     376        uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
     377#if 0
     378        int i;
     379        for (i = 0; i < instance->port_count; ++i) {
     380                usb_log_debug("port status %d,x%x\n",
     381                        instance->registers->rh_port_status[i],
     382                        instance->registers->rh_port_status[i]);
     383        }
     384#endif
     385        return EOK;
     386}
     387/*----------------------------------------------------------------------------*/
    282388
    283389/**
    … …  
    291397 */
    292398static int process_get_hub_status_request(rh_t *instance,
    293                 usb_transfer_batch_t * request){
    294         uint32_t * uint32_buffer = (uint32_t*)request->transport_buffer;
     399        usb_transfer_batch_t * request) {
     400        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
     401        request->transfered_size = 4;
    295402        //bits, 0,1,16,17
    296         request->transfered_size = 4;
    297         uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17);
     403        uint32_t mask = 1 | (1 << 1) | (1 << 16) | (1 << 17);
    298404        uint32_buffer[0] = mask & instance->registers->rh_status;
    299405        return EOK;
    300 
    301 }
    302 
    303 
     406}
     407/*----------------------------------------------------------------------------*/
    304408
    305409/**
    … …  
    313417 */
    314418static int process_get_status_request(rh_t *instance,
    315                 usb_transfer_batch_t * request)
    316 {
     419        usb_transfer_batch_t * request) {
    317420        size_t buffer_size = request->buffer_size;
    318421        usb_device_request_setup_packet_t * request_packet =
    319                         (usb_device_request_setup_packet_t*)
    320                         request->setup_buffer;
     422                (usb_device_request_setup_packet_t*)
     423                request->setup_buffer;
    321424
    322425        usb_hub_bm_request_type_t request_type = request_packet->request_type;
    323         if(buffer_size<4/*request_packet->length*/){///\TODO
     426        if (buffer_size < 4/*request_packet->length*/) {///\TODO
    324427                usb_log_warning("requested more data than buffer size\n");
    325428                return EINVAL;
    326429        }
    327430
    328         if(request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
     431        if (request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
    329432                return process_get_hub_status_request(instance, request);
    330         if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
    331                 return process_get_port_status_request(instance, request_packet->index,
    332                                 request);
     433        if (request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
     434                return process_get_port_status_request(instance,
     435                request_packet->index,
     436                request);
    333437        return ENOTSUP;
    334438}
     439/*----------------------------------------------------------------------------*/
    335440
    336441/**
    … …  
    339444 * Result contains bitmap where bit 0 indicates change on hub and
    340445 * bit i indicates change on i`th port (i>0). For more info see
    341  * Hub and Port status bitmap specification in USB specification.
     446 * Hub and Port status bitmap specification in USB specification
     447 * (chapter 11.13.4)
    342448 * @param instance root hub instance
    343449 * @param@out buffer pointer to created interrupt mas
    … …  
    345451 */
    346452static void create_interrupt_mask(rh_t *instance, void ** buffer,
    347                 size_t * buffer_size){
     453        size_t * buffer_size) {
    348454        int bit_count = instance->port_count + 1;
    349         (*buffer_size) = (bit_count / 8) + (bit_count%8==0)?0:1;
     455        (*buffer_size) = (bit_count / 8) + ((bit_count % 8 == 0) ? 0 : 1);
     456
    350457        (*buffer) = malloc(*buffer_size);
    351         uint8_t * bitmap = (uint8_t*)(*buffer);
    352         uint32_t mask = (1<<16) + (1<<17);
    353         bzero(bitmap,(*buffer_size));
    354         if(instance->registers->rh_status & mask){
     458        uint8_t * bitmap = (uint8_t*) (*buffer);
     459        uint32_t mask = (1 << (USB_HUB_FEATURE_C_HUB_LOCAL_POWER + 16))
     460                | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
     461        bzero(bitmap, (*buffer_size));
     462        if (instance->registers->rh_status & mask) {
    355463                bitmap[0] = 1;
    356464        }
    357465        int port;
    358         mask = 0;
    359         int i;
    360         for(i=16;i<=20;++i)
    361                 mask += 1<<i;
    362         for(port = 1; port<=instance->port_count;++port){
    363                 if(mask & instance->registers->rh_port_status[port-1]){
    364                         bitmap[(port+1)/8] += 1<<(port%8);
    365                 }
    366         }
    367 }
    368  
     466        mask = port_status_change_mask;
     467        for (port = 1; port <= instance->port_count; ++port) {
     468                if (mask & instance->registers->rh_port_status[port - 1]) {
     469                        bitmap[(port) / 8] += 1 << (port % 8);
     470                }
     471        }
     472}
     473/*----------------------------------------------------------------------------*/
     474
    369475/**
    370476 * create answer to a descriptor request
    … …  
    377483 */
    378484static int process_get_descriptor_request(rh_t *instance,
    379                 usb_transfer_batch_t *request){
     485        usb_transfer_batch_t *request) {
    380486        usb_device_request_setup_packet_t * setup_request =
    381                         (usb_device_request_setup_packet_t*)request->setup_buffer;
     487                (usb_device_request_setup_packet_t*) request->setup_buffer;
    382488        size_t size;
    383489        const void * result_descriptor = NULL;
    384490        const uint16_t setup_request_value = setup_request->value_high;
    385                         //(setup_request->value_low << 8);
     491        //(setup_request->value_low << 8);
    386492        bool del = false;
    387         switch (setup_request_value)
    388         {
    389                 case USB_DESCTYPE_HUB: {
     493        switch (setup_request_value) {
     494                case USB_DESCTYPE_HUB:
     495                {
    390496                        uint8_t * descriptor;
    391497                        usb_create_serialized_hub_descriptor(
    392498                                instance, &descriptor, &size);
    393499                        result_descriptor = descriptor;
    394                         if(result_descriptor) del = true;
     500                        if (result_descriptor) del = true;
    395501                        break;
    396502                }
    397                 case USB_DESCTYPE_DEVICE: {
     503                case USB_DESCTYPE_DEVICE:
     504                {
    398505                        usb_log_debug("USB_DESCTYPE_DEVICE\n");
    399506                        result_descriptor = &ohci_rh_device_descriptor;
    400                         size = sizeof(ohci_rh_device_descriptor);
     507                        size = sizeof (ohci_rh_device_descriptor);
    401508                        break;
    402509                }
    403                 case USB_DESCTYPE_CONFIGURATION: {
     510                case USB_DESCTYPE_CONFIGURATION:
     511                {
    404512                        usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
    405513                        result_descriptor = instance->descriptors.configuration;
    … …  
    407515                        break;
    408516                }
    409                 case USB_DESCTYPE_INTERFACE: {
     517                case USB_DESCTYPE_INTERFACE:
     518                {
    410519                        usb_log_debug("USB_DESCTYPE_INTERFACE\n");
    411520                        result_descriptor = &ohci_rh_iface_descriptor;
    412                         size = sizeof(ohci_rh_iface_descriptor);
     521                        size = sizeof (ohci_rh_iface_descriptor);
    413522                        break;
    414523                }
    415                 case USB_DESCTYPE_ENDPOINT: {
     524                case USB_DESCTYPE_ENDPOINT:
     525                {
    416526                        usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
    417527                        result_descriptor = &ohci_rh_ep_descriptor;
    418                         size = sizeof(ohci_rh_ep_descriptor);
     528                        size = sizeof (ohci_rh_ep_descriptor);
    419529                        break;
    420530                }
    421                 default: {
    422                         usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value);
    423                         usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ",
    424                                         setup_request->request_type,
    425                                         setup_request->request,
    426                                         setup_request_value,
    427                                         setup_request->index,
    428                                         setup_request->length
    429                                         );
     531                default:
     532                {
     533                        usb_log_debug("USB_DESCTYPE_EINVAL %d \n",
     534                                setup_request->value);
     535                        usb_log_debug("\ttype %d\n\trequest %d\n\tvalue "
     536                                "%d\n\tindex %d\n\tlen %d\n ",
     537                                setup_request->request_type,
     538                                setup_request->request,
     539                                setup_request_value,
     540                                setup_request->index,
     541                                setup_request->length
     542                                );
    430543                        return EINVAL;
    431544                }
    432545        }
    433         if(request->buffer_size < size){
     546        if (request->buffer_size < size) {
    434547                size = request->buffer_size;
    435548        }
    436549        request->transfered_size = size;
    437         memcpy(request->transport_buffer,result_descriptor,size);
    438         usb_log_debug("sent desctiptor: %s\n",
    439                         usb_debug_str_buffer((uint8_t*)request->transport_buffer,size,size));
     550        memcpy(request->transport_buffer, result_descriptor, size);
    440551        if (del)
    441552                free(result_descriptor);
    442553        return EOK;
    443554}
     555/*----------------------------------------------------------------------------*/
    444556
    445557/**
    … …  
    451563 * @return error code
    452564 */
    453 static int process_get_configuration_request(rh_t *instance, 
    454                 usb_transfer_batch_t *request){
     565static int process_get_configuration_request(rh_t *instance,
     566        usb_transfer_batch_t *request) {
    455567        //set and get configuration requests do not have any meaning, only dummy
    456568        //values are returned
    457         if(request->buffer_size != 1)
     569        if (request->buffer_size != 1)
    458570                return EINVAL;
    459571        request->transport_buffer[0] = 1;
    … …  
    461573        return EOK;
    462574}
     575/*----------------------------------------------------------------------------*/
    463576
    464577/**
    465578 * process feature-enabling request on hub
    466  * 
     579 *
    467580 * @param instance root hub instance
    468581 * @param feature feature selector
    … …  
    470583 */
    471584static int process_hub_feature_set_request(rh_t *instance,
    472                 uint16_t feature){
    473         if(! ((1<<feature) & hub_set_feature_valid_mask))
     585        uint16_t feature) {
     586        if (!((1 << feature) & hub_set_feature_valid_mask))
    474587                return EINVAL;
    475588        instance->registers->rh_status =
    476                         (instance->registers->rh_status | (1<<feature))
    477                         & (~ hub_clear_feature_by_writing_one_mask);
    478         return EOK;
    479 }
     589                (instance->registers->rh_status | (1 << feature))
     590                & (~hub_clear_feature_by_writing_one_mask);
     591        return EOK;
     592}
     593/*----------------------------------------------------------------------------*/
    480594
    481595/**
    … …  
    487601 */
    488602static int process_hub_feature_clear_request(rh_t *instance,
    489                 uint16_t feature){
    490         if(! ((1<<feature) & hub_clear_feature_valid_mask))
     603        uint16_t feature) {
     604        if (!((1 << feature) & hub_clear_feature_valid_mask))
    491605                return EINVAL;
    492606        //is the feature cleared directly?
    493         if ((1<<feature) & hub_set_feature_direct_mask){
     607        if ((1 << feature) & hub_set_feature_direct_mask) {
    494608                instance->registers->rh_status =
    495                         (instance->registers->rh_status & (~(1<<feature)))
    496                         & (~ hub_clear_feature_by_writing_one_mask);
    497         }else{//the feature is cleared by writing '1'
     609                        (instance->registers->rh_status & (~(1 << feature)))
     610                        & (~hub_clear_feature_by_writing_one_mask);
     611        } else {//the feature is cleared by writing '1'
    498612                instance->registers->rh_status =
    499                                 (instance->registers->rh_status
    500                                 & (~ hub_clear_feature_by_writing_one_mask))
    501                                 | (1<<feature);
    502         }
    503         return EOK;
    504 }
    505 
    506 
     613                        (instance->registers->rh_status
     614                        & (~hub_clear_feature_by_writing_one_mask))
     615                        | (1 << feature);
     616        }
     617        return EOK;
     618}
     619/*----------------------------------------------------------------------------*/
    507620
    508621/**
    509622 * process feature-enabling request on hub
    510  * 
     623 *
    511624 * @param instance root hub instance
    512625 * @param feature feature selector
    … …  
    516629 */
    517630static int process_port_feature_set_request(rh_t *instance,
    518                 uint16_t feature, uint16_t port){
    519         if(!((1<<feature) & port_set_feature_valid_mask))
    520                 return EINVAL;
    521         if(port<1 || port>instance->port_count)
     631        uint16_t feature, uint16_t port) {
     632        if (!((1 << feature) & port_set_feature_valid_mask))
     633                return EINVAL;
     634        if (port < 1 || port > instance->port_count)
    522635                return EINVAL;
    523636        instance->registers->rh_port_status[port - 1] =
    524                         (instance->registers->rh_port_status[port - 1] | (1<<feature))
    525                         & (~port_clear_feature_valid_mask);
     637                (instance->registers->rh_port_status[port - 1] | (1 << feature))
     638                & (~port_clear_feature_valid_mask);
    526639        /// \TODO any error?
    527640        return EOK;
    528641}
     642/*----------------------------------------------------------------------------*/
    529643
    530644/**
    … …  
    538652 */
    539653static int process_port_feature_clear_request(rh_t *instance,
    540                 uint16_t feature, uint16_t port){
    541         if(!((1<<feature) & port_clear_feature_valid_mask))
    542                 return EINVAL;
    543         if(port<1 || port>instance->port_count)
    544                 return EINVAL;
    545         if(feature == USB_HUB_FEATURE_PORT_POWER)
     654        uint16_t feature, uint16_t port) {
     655        if (!((1 << feature) & port_clear_feature_valid_mask))
     656                return EINVAL;
     657        if (port < 1 || port > instance->port_count)
     658                return EINVAL;
     659        if (feature == USB_HUB_FEATURE_PORT_POWER)
    546660                feature = USB_HUB_FEATURE_PORT_LOW_SPEED;
    547         if(feature == USB_HUB_FEATURE_PORT_SUSPEND)
     661        if (feature == USB_HUB_FEATURE_PORT_SUSPEND)
    548662                feature = USB_HUB_FEATURE_PORT_OVER_CURRENT;
    549663        instance->registers->rh_port_status[port - 1] =
    550                         (instance->registers->rh_port_status[port - 1]
    551                         & (~port_clear_feature_valid_mask))
    552                         | (1<<feature);
     664                (instance->registers->rh_port_status[port - 1]
     665                & (~port_clear_feature_valid_mask))
     666                | (1 << feature);
    553667        /// \TODO any error?
    554668        return EOK;
    555669}
    556 
     670/*----------------------------------------------------------------------------*/
    557671
    558672/**
    559673 * register address to this device
    560  * 
     674 *
    561675 * @param instance root hub instance
    562676 * @param address new address
    … …  
    564678 */
    565679static int process_address_set_request(rh_t *instance,
    566                 uint16_t address){
     680        uint16_t address) {
    567681        instance->address = address;
    568682        return EOK;
    569683}
     684/*----------------------------------------------------------------------------*/
    570685
    571686/**
    … …  
    579694 */
    580695static int process_request_with_output(rh_t *instance,
    581                 usb_transfer_batch_t *request){
     696        usb_transfer_batch_t *request) {
    582697        usb_device_request_setup_packet_t * setup_request =
    583                         (usb_device_request_setup_packet_t*)request->setup_buffer;
    584         if(setup_request->request == USB_DEVREQ_GET_STATUS){
     698                (usb_device_request_setup_packet_t*) request->setup_buffer;
     699        if (setup_request->request == USB_DEVREQ_GET_STATUS) {
    585700                usb_log_debug("USB_DEVREQ_GET_STATUS\n");
    586701                return process_get_status_request(instance, request);
    587702        }
    588         if(setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){
     703        if (setup_request->request == USB_DEVREQ_GET_DESCRIPTOR) {
    589704                usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n");
    590705                return process_get_descriptor_request(instance, request);
    591706        }
    592         if(setup_request->request == USB_DEVREQ_GET_CONFIGURATION){
     707        if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION) {
    593708                usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
    594709                return process_get_configuration_request(instance, request);
    … …  
    596711        return ENOTSUP;
    597712}
     713/*----------------------------------------------------------------------------*/
    598714
    599715/**
    … …  
    607723 */
    608724static int process_request_with_input(rh_t *instance,
    609                 usb_transfer_batch_t *request){
     725        usb_transfer_batch_t *request) {
    610726        usb_device_request_setup_packet_t * setup_request =
    611                         (usb_device_request_setup_packet_t*)request->setup_buffer;
     727                (usb_device_request_setup_packet_t*) request->setup_buffer;
    612728        request->transfered_size = 0;
    613         if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){
     729        if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR) {
    614730                return ENOTSUP;
    615731        }
    616         if(setup_request->request == USB_DEVREQ_SET_CONFIGURATION){
     732        if (setup_request->request == USB_DEVREQ_SET_CONFIGURATION) {
    617733                //set and get configuration requests do not have any meaning,
    618734                //only dummy values are returned
    … …  
    621737        return ENOTSUP;
    622738}
     739/*----------------------------------------------------------------------------*/
    623740
    624741/**
    … …  
    632749 */
    633750static int process_request_without_data(rh_t *instance,
    634                 usb_transfer_batch_t *request){
     751        usb_transfer_batch_t *request) {
    635752        usb_device_request_setup_packet_t * setup_request =
    636                         (usb_device_request_setup_packet_t*)request->setup_buffer;
     753                (usb_device_request_setup_packet_t*) request->setup_buffer;
    637754        request->transfered_size = 0;
    638         if(setup_request->request == USB_DEVREQ_CLEAR_FEATURE){
    639                 if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){
     755        if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE) {
     756                if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) {
    640757                        usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
    641758                        return process_hub_feature_clear_request(instance,
    642                                         setup_request->value);
    643                 }
    644                 if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
     759                                setup_request->value);
     760                }
     761                if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
    645762                        usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
    646763                        return process_port_feature_clear_request(instance,
    647                                         setup_request->value,
    648                                         setup_request->index);
     764                                setup_request->value,
     765                                setup_request->index);
    649766                }
    650767                usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
    651                                 setup_request->request_type);
    652                 return EINVAL;
    653         }
    654         if(setup_request->request == USB_DEVREQ_SET_FEATURE){
    655                 if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){
     768                        setup_request->request_type);
     769                return EINVAL;
     770        }
     771        if (setup_request->request == USB_DEVREQ_SET_FEATURE) {
     772                if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) {
    656773                        usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
    657774                        return process_hub_feature_set_request(instance,
    658                                         setup_request->value);
    659                 }
    660                 if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
     775                                setup_request->value);
     776                }
     777                if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
    661778                        usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
    662779                        return process_port_feature_set_request(instance,
    663                                         setup_request->value,
    664                                         setup_request->index);
    665                 }
    666                 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",setup_request->request_type);
    667                 return EINVAL;
    668         }
    669         if(setup_request->request == USB_DEVREQ_SET_ADDRESS){
     780                                setup_request->value,
     781                                setup_request->index);
     782                }
     783                usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
     784                        setup_request->request_type);
     785                return EINVAL;
     786        }
     787        if (setup_request->request == USB_DEVREQ_SET_ADDRESS) {
    670788                usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
    671                 return process_address_set_request(instance, setup_request->value);
    672         }
    673         usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",setup_request->request_type);
     789                return process_address_set_request(instance,
     790                        setup_request->value);
     791        }
     792        usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",
     793                setup_request->request_type);
    674794        return ENOTSUP;
    675795}
     796/*----------------------------------------------------------------------------*/
    676797
    677798/**
    … …  
    693814 * @return error code
    694815 */
    695 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request){
     816static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request) {
     817        if (!request->setup_buffer) {
     818                usb_log_error("root hub received empty transaction?");
     819                return EINVAL;
     820        }
    696821        int opResult;
    697         if (request->setup_buffer) {
    698                 if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){
    699                         usb_log_error("setup packet too small\n");
    700                         return EINVAL;
    701                 }
    702                 usb_log_info("CTRL packet: %s.\n",
    703                         usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
    704                 usb_device_request_setup_packet_t * setup_request =
    705                                 (usb_device_request_setup_packet_t*)request->setup_buffer;
    706                 if(
    707                         setup_request->request == USB_DEVREQ_GET_STATUS
    708                         || setup_request->request == USB_DEVREQ_GET_DESCRIPTOR
    709                         || setup_request->request == USB_DEVREQ_GET_CONFIGURATION
    710                 ){
     822        if (sizeof (usb_device_request_setup_packet_t) > request->setup_size) {
     823                usb_log_error("setup packet too small\n");
     824                return EINVAL;
     825        }
     826        usb_log_info("CTRL packet: %s.\n",
     827                usb_debug_str_buffer(
     828                (const uint8_t *) request->setup_buffer, 8, 8));
     829        usb_device_request_setup_packet_t * setup_request =
     830                (usb_device_request_setup_packet_t*)
     831                request->setup_buffer;
     832        switch (setup_request->request) {
     833                case USB_DEVREQ_GET_STATUS:
     834                case USB_DEVREQ_GET_DESCRIPTOR:
     835                case USB_DEVREQ_GET_CONFIGURATION:
    711836                        usb_log_debug("processing request with output\n");
    712                         opResult = process_request_with_output(instance,request);
    713                 }else if(
    714                         setup_request->request == USB_DEVREQ_CLEAR_FEATURE
    715                         || setup_request->request == USB_DEVREQ_SET_FEATURE
    716                         || setup_request->request == USB_DEVREQ_SET_ADDRESS
    717                 ){
    718                         usb_log_debug("processing request without additional data\n");
    719                         opResult = process_request_without_data(instance,request);
    720                 }else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR
    721                                 || setup_request->request == USB_DEVREQ_SET_CONFIGURATION
    722                 ){
    723                         usb_log_debug("processing request with input\n");
    724                         opResult = process_request_with_input(instance,request);
    725                 }else{
    726                         usb_log_warning("received unsuported request: %d\n",
    727                                         setup_request->request
    728                                         );
     837                        opResult = process_request_with_output(
     838                                instance, request);
     839                        break;
     840                case USB_DEVREQ_CLEAR_FEATURE:
     841                case USB_DEVREQ_SET_FEATURE:
     842                case USB_DEVREQ_SET_ADDRESS:
     843                        usb_log_debug("processing request without "
     844                                "additional data\n");
     845                        opResult = process_request_without_data(
     846                                instance, request);
     847                        break;
     848                case USB_DEVREQ_SET_DESCRIPTOR:
     849                case USB_DEVREQ_SET_CONFIGURATION:
     850                        usb_log_debug("processing request with "
     851                                "input\n");
     852                        opResult = process_request_with_input(
     853                                instance, request);
     854                        break;
     855                default:
     856                        usb_log_warning("received unsuported request: "
     857                                "%d\n",
     858                                setup_request->request
     859                                );
    729860                        opResult = ENOTSUP;
    730                 }
    731         }else{
    732                 usb_log_error("root hub received empty transaction?");
    733                 opResult = EINVAL;
    734861        }
    735862        return opResult;
    … …  
    737864
    738865/**
    739  * process root hub request
    740  *
    741  * @param instance root hub instance
    742  * @param request structure containing both request and response information
    743  * @return error code
    744  */
    745 int rh_request(rh_t *instance, usb_transfer_batch_t *request)
    746 {
    747         assert(instance);
    748         assert(request);
    749         int opResult;
    750         if(request->transfer_type == USB_TRANSFER_CONTROL){
    751                 usb_log_info("Root hub got CONTROL packet\n");
    752                 opResult = process_ctrl_request(instance,request);
    753         }else if(request->transfer_type == USB_TRANSFER_INTERRUPT){
    754                 usb_log_info("Root hub got INTERRUPT packet\n");
    755                 void * buffer;
    756                 create_interrupt_mask(instance, &buffer,
    757                         &(request->transfered_size));
    758                 memcpy(request->transport_buffer,buffer, request->transfered_size);
    759                 opResult = EOK;
    760         }else{
    761                 opResult = EINVAL;
    762         }
    763         usb_transfer_batch_finish(request, opResult);
    764         return EOK;
    765 }
    766 /*----------------------------------------------------------------------------*/
    767 
    768 
    769 void rh_interrupt(rh_t *instance)
    770 {
    771         usb_log_info("Whoa whoa wait, I`m not supposed to receive any interrupts, am I?\n");
    772         /* TODO: implement? */
    773 }
    774 /**
    775866 * @}
    776867 */

  • uspace/drv/uhci-hcd/batch.c

    r7dfc06fa rc6cb76d  
    8080 * transaction and callback.
    8181 */
    82 usb_transfer_batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
    83     usb_transfer_type_t transfer_type, size_t max_packet_size,
    84     usb_speed_t speed, char *buffer, size_t buffer_size,
    85     char* setup_buffer, size_t setup_size,
     82usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
     83    char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
    8684    usbhc_iface_transfer_in_callback_t func_in,
    87     usbhc_iface_transfer_out_callback_t func_out, void *arg, endpoint_t *ep
    88     )
    89 {
     85    usbhc_iface_transfer_out_callback_t func_out, void *arg)
     86{
     87        assert(ep);
    9088        assert(func_in == NULL || func_out == NULL);
    9189        assert(func_in != NULL || func_out != NULL);
    … …  
    103101        CHECK_NULL_DISPOSE_RETURN(instance,
    104102            "Failed to allocate batch instance.\n");
     103        usb_target_t target =
     104            { .address = ep->address, .endpoint = ep->endpoint };
    105105        usb_transfer_batch_init(instance, target,
    106             transfer_type, speed, max_packet_size,
     106            ep->transfer_type, ep->speed, ep->max_packet_size,
    107107            buffer, NULL, buffer_size, NULL, setup_size, func_in,
    108108            func_out, arg, fun, ep, NULL);
    … …  
    115115        instance->private_data = data;
    116116
    117         data->transfers = (buffer_size + max_packet_size - 1) / max_packet_size;
    118         if (transfer_type == USB_TRANSFER_CONTROL) {
     117        data->transfers =
     118            (buffer_size + ep->max_packet_size - 1) / ep->max_packet_size;
     119        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
    119120                data->transfers += 2;
    120121        }
    … …  
    178179                            instance, i, data->tds[i].status);
    179180                        td_print_status(&data->tds[i]);
    180                         if (instance->ep != NULL)
    181                                 endpoint_toggle_set(instance->ep,
    182                                     td_toggle(&data->tds[i]));
     181                        assert(instance->ep != NULL);
     182
     183                        endpoint_toggle_set(instance->ep,
     184                            td_toggle(&data->tds[i]));
    183185                        if (i > 0)
    184186                                goto substract_ret;

  • uspace/drv/uhci-hcd/batch.h

    r7dfc06fa rc6cb76d  
    4444
    4545usb_transfer_batch_t * batch_get(
    46     ddf_fun_t *fun,
    47                 usb_target_t target,
    48     usb_transfer_type_t transfer_type,
    49                 size_t max_packet_size,
    50     usb_speed_t speed,
    51                 char *buffer,
    52                 size_t size,
    53                 char *setup_buffer,
    54                 size_t setup_size,
     46    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
     47    char *setup_buffer, size_t setup_size,
    5548    usbhc_iface_transfer_in_callback_t func_in,
    5649    usbhc_iface_transfer_out_callback_t func_out,
    57                 void *arg,
    58                 endpoint_t *ep
    59                 );
     50    void *arg);
    6051
    6152void batch_dispose(usb_transfer_batch_t *instance);

  • uspace/drv/uhci-hcd/hc.c

    r7dfc06fa rc6cb76d  
    332332            instance->transfers[batch->speed][batch->transfer_type];
    333333        assert(list);
    334         if (batch->transfer_type == USB_TRANSFER_CONTROL) {
    335                 usb_device_keeper_use_control(
    336                     &instance->manager, batch->target);
    337         }
    338334        transfer_list_add_batch(list, batch);
    339335
    … …  
    373369                        usb_transfer_batch_t *batch =
    374370                            list_get_instance(item, usb_transfer_batch_t, link);
    375                         switch (batch->transfer_type)
    376                         {
    377                         case USB_TRANSFER_CONTROL:
    378                                 usb_device_keeper_release_control(
    379                                     &instance->manager, batch->target);
    380                                 break;
    381                         case USB_TRANSFER_INTERRUPT:
    382                         case USB_TRANSFER_ISOCHRONOUS: {
    383 /*
    384                                 int ret = bandwidth_free(&instance->bandwidth,
    385                                     batch->target.address,
    386                                     batch->target.endpoint,
    387                                     batch->direction);
    388                                 if (ret != EOK)
    389                                         usb_log_warning("Failed(%d) to free "
    390                                             "reserved bw: %s.\n", ret,
    391                                             str_error(ret));
    392 */
    393                                 }
    394                         default:
    395                                 break;
    396                         }
    397                         batch->next_step(batch);
     371                        usb_transfer_batch_finish(batch);
    398372                }
    399373        }

  • uspace/drv/uhci-hcd/iface.c

    r7dfc06fa rc6cb76d  
    4040#include "iface.h"
    4141#include "hc.h"
     42
     43static inline int setup_batch(
     44    ddf_fun_t *fun, usb_target_t target, usb_direction_t direction,
     45    void *data, size_t size, void * setup_data, size_t setup_size,
     46    usbhc_iface_transfer_in_callback_t in,
     47    usbhc_iface_transfer_out_callback_t out, void *arg, const char* name,
     48    hc_t **hc, usb_transfer_batch_t **batch)
     49{
     50        assert(hc);
     51        assert(batch);
     52        assert(fun);
     53        *hc = fun_to_hc(fun);
     54        assert(*hc);
     55
     56        size_t res_bw;
     57        endpoint_t *ep = usb_endpoint_manager_get_ep(&(*hc)->ep_manager,
     58            target.address, target.endpoint, direction, &res_bw);
     59        if (ep == NULL) {
     60                usb_log_error("Endpoint(%d:%d) not registered for %s.\n",
     61                    target.address, target.endpoint, name);
     62                return ENOENT;
     63        }
     64
     65        const size_t bw = bandwidth_count_usb11(
     66            ep->speed, ep->transfer_type, size, ep->max_packet_size);
     67        if (res_bw < bw) {
     68                usb_log_error("Endpoint(%d:%d) %s needs %zu bw "
     69                    "but only %zu is reserved.\n",
     70                    name, target.address, target.endpoint, bw, res_bw);
     71                return ENOSPC;
     72        }
     73        usb_log_debug("%s %d:%d %zu(%zu).\n",
     74            name, target.address, target.endpoint, size, ep->max_packet_size);
     75
     76        assert(ep->speed ==
     77            usb_device_keeper_get_speed(&(*hc)->manager, target.address));
     78//      assert(ep->max_packet_size == max_packet_size);
     79//      assert(ep->transfer_type == USB_TRANSFER_CONTROL);
     80
     81        *batch =
     82            batch_get(fun, ep, data, size, setup_data, setup_size,
     83                in, out, arg);
     84        if (!batch)
     85                return ENOMEM;
     86        return EOK;
     87}
     88
    4289
    4390/** Reserve default address interface function
    … …  
    214261    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    215262{
    216         assert(fun);
    217         hc_t *hc = fun_to_hc(fun);
    218         assert(hc);
    219 
    220         usb_log_debug("Interrupt OUT %d:%d %zu.\n",
    221             target.address, target.endpoint, size);
    222 
    223         size_t res_bw;
    224         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    225             target.address, target.endpoint, USB_DIRECTION_OUT, &res_bw);
    226         if (ep == NULL) {
    227                 usb_log_error("Endpoint(%d:%d) not registered for INT OUT.\n",
    228                         target.address, target.endpoint);
    229                 return ENOENT;
    230         }
    231         const size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
    232             size, ep->max_packet_size);
    233         if (res_bw < bw)
    234         {
    235                 usb_log_error("Endpoint(%d:%d) INT IN needs %zu bw "
    236                     "but only %zu is reserved.\n",
    237                     target.address, target.endpoint, bw, res_bw);
    238                 return ENOENT;
    239         }
    240         assert(ep->speed ==
    241             usb_device_keeper_get_speed(&hc->manager, target.address));
    242         assert(ep->transfer_type == USB_TRANSFER_INTERRUPT);
    243 
    244         usb_transfer_batch_t *batch =
    245             batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    246                 ep->speed, data, size, NULL, 0, NULL, callback, arg, ep);
    247         if (!batch)
    248                 return ENOMEM;
     263        usb_transfer_batch_t *batch = NULL;
     264        hc_t *hc = NULL;
     265        int ret = setup_batch(fun, target, USB_DIRECTION_OUT, data, size,
     266            NULL, 0, NULL, callback, arg, "Interrupt OUT", &hc, &batch);
     267        if (ret != EOK)
     268                return ret;
    249269        batch_interrupt_out(batch);
    250         const int ret = hc_schedule(hc, batch);
     270        ret = hc_schedule(hc, batch);
    251271        if (ret != EOK) {
    252272                batch_dispose(batch);
    … …  
    269289    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    270290{
    271         assert(fun);
    272         hc_t *hc = fun_to_hc(fun);
    273         assert(hc);
    274 
    275         usb_log_debug("Interrupt IN %d:%d %zu.\n",
    276             target.address, target.endpoint, size);
    277 
    278         size_t res_bw;
    279         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    280             target.address, target.endpoint, USB_DIRECTION_IN, &res_bw);
    281         if (ep == NULL) {
    282                 usb_log_error("Endpoint(%d:%d) not registered for INT IN.\n",
    283                     target.address, target.endpoint);
    284                 return ENOENT;
    285         }
    286         const size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
    287             size, ep->max_packet_size);
    288         if (res_bw < bw)
    289         {
    290                 usb_log_error("Endpoint(%d:%d) INT IN needs %zu bw "
    291                     "but only %zu bw is reserved.\n",
    292                     target.address, target.endpoint, bw, res_bw);
    293                 return ENOENT;
    294         }
    295 
    296         assert(ep->speed ==
    297             usb_device_keeper_get_speed(&hc->manager, target.address));
    298         assert(ep->transfer_type == USB_TRANSFER_INTERRUPT);
    299 
    300         usb_transfer_batch_t *batch =
    301             batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    302                 ep->speed, data, size, NULL, 0, callback, NULL, arg, ep);
    303         if (!batch)
    304                 return ENOMEM;
     291        usb_transfer_batch_t *batch = NULL;
     292        hc_t *hc = NULL;
     293        int ret = setup_batch(fun, target, USB_DIRECTION_IN, data, size,
     294            NULL, 0, callback, NULL, arg, "Interrupt IN", &hc, &batch);
     295        if (ret != EOK)
     296                return ret;
    305297        batch_interrupt_in(batch);
    306         const int ret = hc_schedule(hc, batch);
     298        ret = hc_schedule(hc, batch);
    307299        if (ret != EOK) {
    308300                batch_dispose(batch);
    … …  
    325317    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    326318{
    327         assert(fun);
    328         hc_t *hc = fun_to_hc(fun);
    329         assert(hc);
    330 
    331         usb_log_debug("Bulk OUT %d:%d %zu.\n",
    332             target.address, target.endpoint, size);
    333 
    334         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    335             target.address, target.endpoint, USB_DIRECTION_OUT, NULL);
    336         if (ep == NULL) {
    337                 usb_log_error("Endpoint(%d:%d) not registered for BULK OUT.\n",
    338                         target.address, target.endpoint);
    339                 return ENOENT;
    340         }
    341         assert(ep->speed ==
    342             usb_device_keeper_get_speed(&hc->manager, target.address));
    343         assert(ep->transfer_type == USB_TRANSFER_BULK);
    344 
    345         usb_transfer_batch_t *batch =
    346             batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    347                 ep->speed, data, size, NULL, 0, NULL, callback, arg, ep);
    348         if (!batch)
    349                 return ENOMEM;
     319        usb_transfer_batch_t *batch = NULL;
     320        hc_t *hc = NULL;
     321        int ret = setup_batch(fun, target, USB_DIRECTION_OUT, data, size,
     322            NULL, 0, NULL, callback, arg, "Bulk OUT", &hc, &batch);
     323        if (ret != EOK)
     324                return ret;
    350325        batch_bulk_out(batch);
    351         const int ret = hc_schedule(hc, batch);
     326        ret = hc_schedule(hc, batch);
    352327        if (ret != EOK) {
    353328                batch_dispose(batch);
    … …  
    370345    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    371346{
    372         assert(fun);
    373         hc_t *hc = fun_to_hc(fun);
    374         assert(hc);
    375         usb_log_debug("Bulk IN %d:%d %zu.\n",
    376             target.address, target.endpoint, size);
    377 
    378         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    379             target.address, target.endpoint, USB_DIRECTION_IN, NULL);
    380         if (ep == NULL) {
    381                 usb_log_error("Endpoint(%d:%d) not registered for BULK IN.\n",
    382                         target.address, target.endpoint);
    383                 return ENOENT;
    384         }
    385         assert(ep->speed ==
    386             usb_device_keeper_get_speed(&hc->manager, target.address));
    387         assert(ep->transfer_type == USB_TRANSFER_BULK);
    388 
    389         usb_transfer_batch_t *batch =
    390             batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    391                 ep->speed, data, size, NULL, 0, callback, NULL, arg, ep);
    392         if (!batch)
    393                 return ENOMEM;
     347        usb_transfer_batch_t *batch = NULL;
     348        hc_t *hc = NULL;
     349        int ret = setup_batch(fun, target, USB_DIRECTION_IN, data, size,
     350            NULL, 0, callback, NULL, arg, "Bulk IN", &hc, &batch);
     351        if (ret != EOK)
     352                return ret;
    394353        batch_bulk_in(batch);
    395         const int ret = hc_schedule(hc, batch);
     354        ret = hc_schedule(hc, batch);
    396355        if (ret != EOK) {
    397356                batch_dispose(batch);
    … …  
    417376    usbhc_iface_transfer_out_callback_t callback, void *arg)
    418377{
    419         assert(fun);
    420         hc_t *hc = fun_to_hc(fun);
    421         assert(hc);
    422         usb_speed_t speed =
    423             usb_device_keeper_get_speed(&hc->manager, target.address);
    424         usb_log_debug("Control WRITE (%d) %d:%d %zu.\n",
    425             speed, target.address, target.endpoint, size);
    426         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    427             target.address, target.endpoint, USB_DIRECTION_BOTH, NULL);
    428         if (ep == NULL) {
    429                 usb_log_warning("Endpoint(%d:%d) not registered for CONTROL.\n",
    430                         target.address, target.endpoint);
    431         }
    432 
    433         if (setup_size != 8)
    434                 return EINVAL;
    435 
    436         usb_transfer_batch_t *batch =
    437             batch_get(fun, target, USB_TRANSFER_CONTROL, ep->max_packet_size, speed,
    438                 data, size, setup_data, setup_size, NULL, callback, arg, ep);
    439         if (!batch)
    440                 return ENOMEM;
     378        usb_transfer_batch_t *batch = NULL;
     379        hc_t *hc = NULL;
     380        int ret = setup_batch(fun, target, USB_DIRECTION_BOTH, data, size,
     381            setup_data, setup_size, NULL, callback, arg, "Control WRITE",
     382            &hc, &batch);
     383        if (ret != EOK)
     384                return ret;
    441385        usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
    442386        batch_control_write(batch);
    443         const int ret = hc_schedule(hc, batch);
     387        ret = hc_schedule(hc, batch);
    444388        if (ret != EOK) {
    445389                batch_dispose(batch);
    … …  
    465409    usbhc_iface_transfer_in_callback_t callback, void *arg)
    466410{
    467         assert(fun);
    468         hc_t *hc = fun_to_hc(fun);
    469         assert(hc);
    470         usb_speed_t speed =
    471             usb_device_keeper_get_speed(&hc->manager, target.address);
    472 
    473         usb_log_debug("Control READ(%d) %d:%d %zu.\n",
    474             speed, target.address, target.endpoint, size);
    475         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    476             target.address, target.endpoint, USB_DIRECTION_BOTH, NULL);
    477         if (ep == NULL) {
    478                 usb_log_warning("Endpoint(%d:%d) not registered for CONTROL.\n",
    479                         target.address, target.endpoint);
    480         }
    481         usb_transfer_batch_t *batch =
    482             batch_get(fun, target, USB_TRANSFER_CONTROL, ep->max_packet_size, speed,
    483                 data, size, setup_data, setup_size, callback, NULL, arg, ep);
    484         if (!batch)
    485                 return ENOMEM;
     411        usb_transfer_batch_t *batch = NULL;
     412        hc_t *hc = NULL;
     413        int ret = setup_batch(fun, target, USB_DIRECTION_BOTH, data, size,
     414            setup_data, setup_size, callback, NULL, arg, "Control READ",
     415            &hc, &batch);
     416        if (ret != EOK)
     417                return ret;
    486418        batch_control_read(batch);
    487         const int ret = hc_schedule(hc, batch);
     419        ret = hc_schedule(hc, batch);
    488420        if (ret != EOK) {
    489421                batch_dispose(batch);

  • uspace/drv/uhci-hcd/transfer_list.c

    r7dfc06fa rc6cb76d  
    132132}
    133133/*----------------------------------------------------------------------------*/
    134 /** Check list for finished batches.
    135  *
    136  * @param[in] instance List to use.
    137  * @return Error code
    138  *
    139  * Creates a local list of finished batches and calls next_step on each and
    140  * every one. This is safer because next_step may theoretically access
    141  * this transfer list leading to the deadlock if its done inline.
     134/** Create list for finished batches.
     135 *
     136 * @param[in] instance List to use.
     137 * @param[in] done list to fill
    142138 */
    143139void transfer_list_remove_finished(transfer_list_t *instance, link_t *done)
    … …  
    161157        }
    162158        fibril_mutex_unlock(&instance->guard);
    163 
    164159}
    165160/*----------------------------------------------------------------------------*/
    … …  
    176171                    list_get_instance(current, usb_transfer_batch_t, link);
    177172                transfer_list_remove_batch(instance, batch);
    178                 usb_transfer_batch_finish(batch, EIO);
     173                usb_transfer_batch_finish_error(batch, EIO);
    179174        }
    180175        fibril_mutex_unlock(&instance->guard);

  • uspace/drv/uhci-rhd/root_hub.h

    r7dfc06fa rc6cb76d  
    4040
    4141#define UHCI_ROOT_HUB_PORT_COUNT 2
    42 #define ROOT_HUB_WAIT_USEC 5000000 /* 5 seconds */
     42#define ROOT_HUB_WAIT_USEC 250000 /* 250 miliseconds */
    4343
    4444typedef struct root_hub {

  • uspace/drv/usbkbd/kbddev.c

    r7dfc06fa rc6cb76d  
    265265static void usb_kbd_set_led(usb_kbd_t *kbd_dev)
    266266{
     267        if (kbd_dev->output_size == 0) {
     268                return;
     269        }
     270       
    267271        unsigned i = 0;
    268272       
    … …  
    288292       
    289293        int rc = usb_hid_report_output_translate(kbd_dev->parser,
    290             kbd_dev->led_path, USB_HID_PATH_COMPARE_END, kbd_dev->output_buffer,
     294            kbd_dev->led_path,
     295            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
     296            kbd_dev->output_buffer,
    291297            kbd_dev->output_size, kbd_dev->led_data, kbd_dev->led_output_size);
    292298       
    … …  
    539545 *                  according to HID Usage Tables.
    540546 * @param count Number of key codes in report (size of the report).
    541  * @param modifiers Bitmap of modifiers (Ctrl, Alt, Shift, GUI).
     547 * @param report_id
    542548 * @param arg User-specified argument. Expects pointer to the keyboard device
    543549 *            structure representing the keyboard.
    … …  
    546552 */
    547553static void usb_kbd_process_keycodes(const uint8_t *key_codes, size_t count,
    548     uint8_t modifiers, void *arg)
     554    uint8_t report_id, void *arg)
    549555{
    550556        if (arg == NULL) {
    … …  
    557563        assert(kbd_dev != NULL);
    558564
    559         usb_log_debug("Got keys from parser: %s\n",
    560             usb_debug_str_buffer(key_codes, count, 0));
     565        usb_log_debug("Got keys from parser (report id: %u): %s\n",
     566            report_id, usb_debug_str_buffer(key_codes, count, 0));
    561567       
    562568        if (count != kbd_dev->key_count) {
    … …  
    608614        usb_hid_report_path_t *path = usb_hid_report_path();
    609615        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
     616        usb_hid_report_path_set_report_id(path, 0);
    610617       
    611618        int rc = usb_hid_parse_report(kbd_dev->parser, buffer,
    612             actual_size, path, USB_HID_PATH_COMPARE_STRICT, callbacks, kbd_dev);
     619            actual_size, path,
     620            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
     621            callbacks, kbd_dev);
    613622
    614623        usb_hid_report_path_free (path);
    … …  
    758767        usb_hid_report_path_t *path = usb_hid_report_path();
    759768        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
     769       
     770        usb_hid_report_path_set_report_id(path, 0);
     771       
    760772        kbd_dev->key_count = usb_hid_report_input_length(
    761             kbd_dev->parser, path, USB_HID_PATH_COMPARE_STRICT);
     773            kbd_dev->parser, path,
     774            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
    762775        usb_hid_report_path_free (path);
    763776       
    … …  
    777790        kbd_dev->output_buffer = usb_hid_report_output(kbd_dev->parser,
    778791            &kbd_dev->output_size);
    779         if (kbd_dev->output_buffer == NULL) {
     792        if (kbd_dev->output_buffer == NULL && kbd_dev->output_size != 0) {
    780793                usb_log_warning("Error creating output report buffer.\n");
    781794                free(kbd_dev->keys);
    … …  
    790803       
    791804        kbd_dev->led_output_size = usb_hid_report_output_size(kbd_dev->parser,
    792             kbd_dev->led_path, USB_HID_PATH_COMPARE_END);
     805            kbd_dev->led_path,
     806            USB_HID_PATH_COMPARE_END | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY);
    793807       
    794808        usb_log_debug("Output report size (in items): %zu\n",

  • uspace/drv/usbkbd/main.c

    r7dfc06fa rc6cb76d  
    3333/**
    3434 * @file
    35  * Main routines of USB HID driver.
     35 * Main routines of USB KBD driver.
    3636 */
    3737
    … …  
    7575 * @sa usb_kbd_fibril(), usb_kbd_repeat_fibril()
    7676 */
    77 static int usbhid_try_add_device(usb_device_t *dev)
     77static int usb_kbd_try_add_device(usb_device_t *dev)
    7878{
    7979        /* Create the function exposed under /dev/devices. */
    … …  
    105105                usb_kbd_free(&kbd_dev);
    106106                return rc;
    107         }       
     107        }
    108108       
    109109        usb_log_debug("USB/HID KBD device structure initialized.\n");
    … …  
    195195 * @retval EREFUSED if the device is not supported.
    196196 */
    197 static int usbhid_add_device(usb_device_t *dev)
     197static int usb_kbd_add_device(usb_device_t *dev)
    198198{
    199         usb_log_debug("usbhid_add_device()\n");
     199        usb_log_debug("usb_kbd_add_device()\n");
    200200       
    201201        if (dev->interface_no < 0) {
    202202                usb_log_warning("Device is not a supported keyboard.\n");
    203                 usb_log_error("Failed to add HID device: endpoint not found."
    204                     "\n");
     203                usb_log_error("Failed to add USB KBD device: endpoint not "
     204                    "found.\n");
    205205                return ENOTSUP;
    206206        }
    207207       
    208         int rc = usbhid_try_add_device(dev);
     208        int rc = usb_kbd_try_add_device(dev);
    209209       
    210210        if (rc != EOK) {
    211211                usb_log_warning("Device is not a supported keyboard.\n");
    212                 usb_log_error("Failed to add HID device: %s.\n",
     212                usb_log_error("Failed to add KBD device: %s.\n",
    213213                    str_error(rc));
    214214                return rc;
    … …  
    224224/* Currently, the framework supports only device adding. Once the framework
    225225 * supports unplug, more callbacks will be added. */
    226 static usb_driver_ops_t usbhid_driver_ops = {
    227         .add_device = usbhid_add_device,
     226static usb_driver_ops_t usb_kbd_driver_ops = {
     227        .add_device = usb_kbd_add_device,
    228228};
    229229
    230230
    231231/* The driver itself. */
    232 static usb_driver_t usbhid_driver = {
     232static usb_driver_t usb_kbd_driver = {
    233233        .name = NAME,
    234         .ops = &usbhid_driver_ops,
     234        .ops = &usb_kbd_driver_ops,
    235235        .endpoints = usb_kbd_endpoints
    236236};
    … …  
    238238/*----------------------------------------------------------------------------*/
    239239
    240 //static driver_ops_t kbd_driver_ops = {
    241 //      .add_device = usbhid_add_device,
    242 //};
    243 
    244 ///*----------------------------------------------------------------------------*/
    245 
    246 //static driver_t kbd_driver = {
    247 //      .name = NAME,
    248 //      .driver_ops = &kbd_driver_ops
    249 //};
    250 
    251 /*----------------------------------------------------------------------------*/
    252 
    253240int main(int argc, char *argv[])
    254241{
    255         printf(NAME ": HelenOS USB HID driver.\n");
     242        printf(NAME ": HelenOS USB KBD driver.\n");
    256243
    257244        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
    258245
    259         return usb_driver_main(&usbhid_driver);
     246        return usb_driver_main(&usb_kbd_driver);
    260247}
    261248

  • uspace/drv/usbkbd/usbkbd.ma

    r7dfc06fa rc6cb76d  
    1 100 usb&interface&class=HID&subclass=0x01&protocol=0x01
    2 10 usb&interface&class=HID
     110 usb&interface&class=HID&subclass=0x01&protocol=0x01

  • uspace/lib/usb/include/usb/classes/hidparser.h

    r7dfc06fa rc6cb76d  
    8888        /** */ 
    8989        int depth;     
     90        uint8_t report_id;
    9091       
    9192        /** */ 
    9293        link_t link;
     94
    9395} usb_hid_report_path_t;
    9496
    … …  
    155157        /** */ 
    156158        link_t feature;
     159       
     160        int use_report_id;
     161
     162        /** */
     163        link_t stack;
    157164} usb_hid_report_parser_t;     
    158165
    … …  
    166173         * @param arg Custom argument.
    167174         */
    168         void (*keyboard)(const uint8_t *key_codes, size_t count, const uint8_t modifiers, void *arg);
     175        void (*keyboard)(const uint8_t *key_codes, size_t count, const uint8_t report_id, void *arg);
    169176} usb_hid_report_in_callbacks_t;
    170177
    … …  
    269276
    270277/** */
     278int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path, uint8_t report_id);
     279
     280/** */
    271281int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, int32_t usage_page, int32_t usage);
    272282

  • uspace/lib/usb/include/usb/host/batch.h

    r7dfc06fa rc6cb76d  
    9292void usb_transfer_batch_call_in(usb_transfer_batch_t *instance);
    9393void usb_transfer_batch_call_out(usb_transfer_batch_t *instance);
    94 void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error);
     94void usb_transfer_batch_finish(usb_transfer_batch_t *instance);
     95
     96static inline void usb_transfer_batch_finish_error(
     97    usb_transfer_batch_t *instance, int error)
     98{
     99        assert(instance);
     100        instance->error = error;
     101        usb_transfer_batch_finish(instance);
     102}
    95103
    96104#endif

  • uspace/lib/usb/include/usb/host/device_keeper.h

    r7dfc06fa rc6cb76d  
    9696usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
    9797    usb_address_t address);
    98 
    99 void usb_device_keeper_use_control(usb_device_keeper_t *instance,
    100     usb_target_t target);
    101 
    102 void usb_device_keeper_release_control(usb_device_keeper_t *instance,
    103     usb_target_t target);
    104 
    10598#endif
    10699/**

  • uspace/lib/usb/include/usb/host/endpoint.h

    r7dfc06fa rc6cb76d  
    3939#include <bool.h>
    4040#include <adt/list.h>
     41#include <fibril_synch.h>
     42
    4143#include <usb/usb.h>
    4244
    … …  
    4850        usb_speed_t speed;
    4951        size_t max_packet_size;
    50         bool active;
    5152        unsigned toggle:1;
     53        fibril_mutex_t guard;
     54        fibril_condvar_t avail;
     55        volatile bool active;
    5256        link_t same_device_eps;
    5357} endpoint_t;
    … …  
    5862
    5963void endpoint_destroy(endpoint_t *instance);
     64
     65void endpoint_use(endpoint_t *instance);
     66
     67void endpoint_release(endpoint_t *instance);
    6068
    6169int endpoint_toggle_get(endpoint_t *instance);

  • uspace/lib/usb/src/devpoll.c

    r7dfc06fa rc6cb76d  
    6666        usb_pipe_t *pipe
    6767            = polling_data->dev->pipes[polling_data->pipe_index].pipe;
     68       
     69        usb_log_debug("Pipe interface number: %d, protocol: %d, subclass: %d, max packet size: %d\n",
     70            polling_data->dev->pipes[polling_data->pipe_index].interface_no,
     71            polling_data->dev->pipes[polling_data->pipe_index].description->interface_protocol,
     72            polling_data->dev->pipes[polling_data->pipe_index].description->interface_subclass,
     73            pipe->max_packet_size);
    6874
    6975        size_t failed_attempts = 0;
    … …  
    8389                /* Quit the session regardless of errors. */
    8490                usb_pipe_end_session(pipe);
     91               
     92//              if (rc == ESTALL) {
     93//                      usb_log_debug("Seding clear feature...\n");
     94//                      usb_request_clear_feature(pipe, USB_REQUEST_TYPE_STANDARD,
     95//                        USB_REQUEST_RECIPIENT_ENDPOINT, 0, pipe->endpoint_no);
     96//                      continue;
     97//              }
    8598
    8699                if (rc != EOK) {

  • uspace/lib/usb/src/hidparser.c

    r7dfc06fa rc6cb76d  
    6464int usb_hid_report_reset_local_items();
    6565void usb_hid_free_report_list(link_t *head);
    66 
     66usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item);
    6767/*
    6868 * Data translation private functions
    … …  
    106106    list_initialize(&(parser->feature));
    107107
     108        list_initialize(&(parser->stack));
     109
     110        parser->use_report_id = 0;
    108111    return EOK;   
    109112}
    … …  
    186189                                        tmp_usage_path = NULL;
    187190
     191                                        usb_hid_report_path_set_report_id(report_item->usage_path, report_item->id);   
     192                                        if(report_item->id != 0){
     193                                                parser->use_report_id = 1;
     194                                        }
    188195                                       
    189196                                        switch(tag) {
    … …  
    215222                                        if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
    216223                                                return ENOMEM;
    217                                         }
     224                                        }                                       
    218225                                        memcpy(new_report_item,report_item, sizeof(usb_hid_report_item_t));
     226                                        link_initialize(&(new_report_item->link));
     227                                       
    219228                                        /* reset local items */
    220229                                        new_report_item->usage_minimum = 0;
    221230                                        new_report_item->usage_maximum = 0;
     231                                        new_report_item->designator_index = 0;
     232                                        new_report_item->designator_minimum = 0;
     233                                        new_report_item->designator_maximum = 0;
     234                                        new_report_item->string_index = 0;
     235                                        new_report_item->string_minimum = 0;
     236                                        new_report_item->string_maximum = 0;
     237
     238                                        /* reset usage from current usage path */
     239                                        usb_hid_report_usage_path_t *path = list_get_instance(&usage_path->link, usb_hid_report_usage_path_t, link);
     240                                        path->usage = 0;
    222241                                       
    223                                         link_initialize(&(new_report_item->link));
    224242                                        report_item = new_report_item;
    225243                                                                               
    … …  
    227245                                case USB_HID_REPORT_TAG_PUSH:
    228246                                        // push current state to stack
    229                                         // not yet implemented
     247                                        new_report_item = usb_hid_report_item_clone(report_item);
     248                                        list_prepend (&parser->stack, &new_report_item->link);
     249                                       
    230250                                        break;
    231251                                case USB_HID_REPORT_TAG_POP:
    232252                                        // restore current state from stack
    233                                         // not yet implemented                                             
     253                                        if(list_empty (&parser->stack)) {
     254                                                return EINVAL;
     255                                        }
     256                                       
     257                                        report_item = list_get_instance(&parser->stack, usb_hid_report_item_t, link);
     258                                        list_remove (parser->stack.next);
     259                                       
    234260                                        break;
    235261                                       
    … …  
    647673        }
    648674
     675        parser->use_report_id = 0;
     676
    649677        usb_hid_free_report_list(&parser->input);
    650678        usb_hid_free_report_list(&parser->output);
    … …  
    676704        size_t i=0;
    677705        size_t j=0;
     706        uint8_t report_id = 0;
    678707
    679708        if(parser == NULL) {
    … …  
    686715        if(!(keys = malloc(sizeof(uint8_t) * key_count))){
    687716                return ENOMEM;
     717        }
     718
     719        if(parser->use_report_id != 0) {
     720                report_id = data[0];
     721                usb_hid_report_path_set_report_id(path, report_id);
    688722        }
    689723
    … …  
    693727
    694728                item = list_get_instance(list_item, usb_hid_report_item_t, link);
     729
    695730                if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) &&
    696731                   (usb_hid_report_compare_usage_path(item->usage_path, path, flags) == EOK)) {
    … …  
    715750        }
    716751
    717         callbacks->keyboard(keys, key_count, 0, arg);
     752        callbacks->keyboard(keys, key_count, report_id, arg);
    718753           
    719754        free(keys);     
    … …  
    739774        int32_t mask;
    740775        const uint8_t *foo;
    741        
     776
    742777        // now only common numbers llowed
    743778        if(item->size > 32) {
    … …  
    758793                (usb_pow(10,(item->unit_exponent))));
    759794        }
     795
    760796        offset = item->offset + (j * item->size);
     797        if(item->id != 0) {
     798                offset += 8;
     799                usb_log_debug("MOVED OFFSET BY 1Byte, REPORT_ID(%d)\n", item->id);
     800        }
    761801       
    762802        // FIXME
    … …  
    942982
    943983        int only_page;
     984
     985        if(report_path->report_id != path->report_id) {
     986                return 1;
     987        }
    944988
    945989        if(path->depth == 0){
    … …  
    10381082        else {
    10391083                path->depth = 0;
     1084                path->report_id = 0;
    10401085                list_initialize(&path->link);
    10411086                return path;
    … …  
    11551200                return 0;
    11561201        }
    1157        
     1202
    11581203        item = parser->output.next;
    11591204        while(&parser->output != item) {
    … …  
    11951240        int length;
    11961241        int32_t tmp_value;
     1242        size_t offset_prefix = 0;
    11971243       
    11981244        if(parser == NULL) {
    11991245                return EINVAL;
     1246        }
     1247
     1248        if(parser->use_report_id != 0) {
     1249                buffer[0] = path->report_id;
     1250                offset_prefix = 8;
    12001251        }
    12011252
    … …  
    12181269//                              // variable item
    12191270                                value = usb_hid_translate_data_reverse(report_item, data[idx++]);
    1220                                 offset = report_item->offset + (i * report_item->size);
     1271                                offset = report_item->offset + (i * report_item->size) + offset_prefix;
    12211272                                length = report_item->size;
    12221273                        }
    … …  
    12241275                                //bitmap
    12251276                                value += usb_hid_translate_data_reverse(report_item, data[idx++]);
    1226                                 offset = report_item->offset;
     1277                                offset = report_item->offset + offset_prefix;
    12271278                                length = report_item->size * report_item->count;
    12281279                        }
    … …  
    13231374
    13241375
     1376int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id)
     1377{
     1378        if(path == NULL){
     1379                return EINVAL;
     1380        }
     1381
     1382        path->report_id = report_id;
     1383        return EOK;
     1384}
     1385
     1386
     1387usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item)
     1388{
     1389        usb_hid_report_item_t *new_report_item;
     1390       
     1391        if(!(new_report_item = malloc(sizeof(usb_hid_report_item_t)))) {
     1392                return NULL;
     1393        }                                       
     1394        memcpy(new_report_item,item, sizeof(usb_hid_report_item_t));
     1395        link_initialize(&(new_report_item->link));
     1396
     1397        return new_report_item;
     1398}
     1399
    13251400/**
    13261401 * @}

  • uspace/lib/usb/src/hidreport.c

    r7dfc06fa rc6cb76d  
    8080                d = usb_dp_get_sibling_descriptor(&parser, &parser_data,
    8181                    dev->descriptors.configuration, d);
     82                ++i;
    8283        }
    8384       

  • uspace/lib/usb/src/host/batch.c

    r7dfc06fa rc6cb76d  
    7979        instance->error = EOK;
    8080        instance->ep = ep;
     81        endpoint_use(instance->ep);
    8182}
    8283/*----------------------------------------------------------------------------*/
    … …  
    8687 *
    8788 */
    88 void usb_transfer_batch_finish(usb_transfer_batch_t *instance, int error)
     89void usb_transfer_batch_finish(usb_transfer_batch_t *instance)
    8990{
    9091        assert(instance);
    91         instance->error = error;
     92        assert(instance->ep);
     93        endpoint_release(instance->ep);
    9294        instance->next_step(instance);
    9395}

  • uspace/lib/usb/src/host/device_keeper.c

    r7dfc06fa rc6cb76d  
    264264        return instance->devices[address].speed;
    265265}
    266 /*----------------------------------------------------------------------------*/
    267 void usb_device_keeper_use_control(
    268     usb_device_keeper_t *instance, usb_target_t target)
    269 {
    270         assert(instance);
    271         const uint16_t ep = 1 << target.endpoint;
    272         fibril_mutex_lock(&instance->guard);
    273         while (instance->devices[target.address].control_used & ep) {
    274                 fibril_condvar_wait(&instance->change, &instance->guard);
    275         }
    276         instance->devices[target.address].control_used |= ep;
    277         fibril_mutex_unlock(&instance->guard);
    278 }
    279 /*----------------------------------------------------------------------------*/
    280 void usb_device_keeper_release_control(
    281     usb_device_keeper_t *instance, usb_target_t target)
    282 {
    283         assert(instance);
    284         const uint16_t ep = 1 << target.endpoint;
    285         fibril_mutex_lock(&instance->guard);
    286         assert((instance->devices[target.address].control_used & ep) != 0);
    287         instance->devices[target.address].control_used &= ~ep;
    288         fibril_mutex_unlock(&instance->guard);
    289         fibril_condvar_signal(&instance->change);
    290 }
    291266/**
    292267 * @}

  • uspace/lib/usb/src/host/endpoint.c

    r7dfc06fa rc6cb76d  
    3434 */
    3535
     36#include <assert.h>
    3637#include <errno.h>
    3738#include <usb/host/endpoint.h>
    … …  
    4950        instance->max_packet_size = max_packet_size;
    5051        instance->toggle = 0;
     52        instance->active = false;
     53        fibril_mutex_initialize(&instance->guard);
     54        fibril_condvar_initialize(&instance->avail);
    5155        link_initialize(&instance->same_device_eps);
    5256        return EOK;
    … …  
    5660{
    5761        assert(instance);
     62        assert(!instance->active);
    5863        list_remove(&instance->same_device_eps);
    5964        free(instance);
     65}
     66/*----------------------------------------------------------------------------*/
     67void endpoint_use(endpoint_t *instance)
     68{
     69        assert(instance);
     70        fibril_mutex_lock(&instance->guard);
     71        while (instance->active)
     72                fibril_condvar_wait(&instance->avail, &instance->guard);
     73        instance->active = true;
     74        fibril_mutex_unlock(&instance->guard);
     75}
     76/*----------------------------------------------------------------------------*/
     77void endpoint_release(endpoint_t *instance)
     78{
     79        assert(instance);
     80        fibril_mutex_lock(&instance->guard);
     81        instance->active = false;
     82        fibril_mutex_unlock(&instance->guard);
     83        fibril_condvar_signal(&instance->avail);
    6084}
    6185/*----------------------------------------------------------------------------*/

  • uspace/lib/usb/src/hub.c

    r7dfc06fa rc6cb76d  
    178178 * error codes than those listed as return codes by this function itself).
    179179 *
     180 * The @p connection representing connection with host controller does not
     181 * need to be started.
     182 * This function duplicates the connection to allow simultaneous calls of
     183 * this function (i.e. from different fibrils).
     184 *
    180185 * @param[in] parent Parent device (i.e. the hub device).
    181  * @param[in] connection Opened connection to host controller.
     186 * @param[in] connection Connection to host controller.
    182187 * @param[in] dev_speed New device speed.
    183188 * @param[in] enable_port Function for enabling signaling through the port the
    … …  
    206211    ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun)
    207212{
    208         CHECK_CONNECTION(connection);
     213        assert(connection != NULL);
     214        // FIXME: this is awful, we are accessing directly the structure.
     215        usb_hc_connection_t hc_conn = {
     216                .hc_handle = connection->hc_handle,
     217                .hc_phone = -1
     218        };
     219
     220        int rc;
     221
     222        rc = usb_hc_connection_open(&hc_conn);
     223        if (rc != EOK) {
     224                return rc;
     225        }
     226
    209227
    210228        /*
    211229         * Request new address.
    212230         */
    213         usb_address_t dev_addr = usb_hc_request_address(connection, dev_speed);
     231        usb_address_t dev_addr = usb_hc_request_address(&hc_conn, dev_speed);
    214232        if (dev_addr < 0) {
     233                usb_hc_connection_close(&hc_conn);
    215234                return EADDRNOTAVAIL;
    216235        }
    217236
    218         int rc;
    219237
    220238        /*
    221239         * Reserve the default address.
    222240         */
    223         rc = usb_hc_reserve_default_address(connection, dev_speed);
     241        rc = usb_hc_reserve_default_address(&hc_conn, dev_speed);
    224242        if (rc != EOK) {
    225243                rc = EBUSY;
    … …  
    241259        usb_device_connection_t dev_conn;
    242260        rc = usb_device_connection_initialize_on_default_address(&dev_conn,
    243             connection);
     261            &hc_conn);
    244262        if (rc != EOK) {
    245263                rc = ENOTCONN;
    … …  
    258276         * endpoint.
    259277         */
    260         rc = usb_pipe_register(&ctrl_pipe, 0, connection);
     278        rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
    261279        if (rc != EOK) {
    262280                rc = EREFUSED;
    … …  
    286304         * Register the control endpoint for the new device.
    287305         */
    288         rc = usb_pipe_register(&ctrl_pipe, 0, connection);
     306        rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
    289307        if (rc != EOK) {
    290308                rc = EREFUSED;
    … …  
    295313         * Release the original endpoint.
    296314         */
    297         unregister_control_endpoint_on_default_address(connection);
     315        unregister_control_endpoint_on_default_address(&hc_conn);
    298316
    299317        /*
    300318         * Once the address is changed, we can return the default address.
    301319         */
    302         usb_hc_release_default_address(connection);
     320        usb_hc_release_default_address(&hc_conn);
    303321
    304322
    … …  
    325343                .handle = child_handle
    326344        };
    327         rc = usb_hc_register_device(connection, &new_device);
     345        rc = usb_hc_register_device(&hc_conn, &new_device);
    328346        if (rc != EOK) {
    329347                rc = EDESTADDRREQ;
    … …  
    354372
    355373leave_unregister_endpoint:
    356         usb_pipe_unregister(&ctrl_pipe, connection);
     374        usb_pipe_unregister(&ctrl_pipe, &hc_conn);
    357375
    358376leave_release_default_address:
    359         usb_hc_release_default_address(connection);
     377        usb_hc_release_default_address(&hc_conn);
    360378
    361379leave_release_free_address:
    362         usb_hc_unregister_device(connection, dev_addr);
     380        usb_hc_unregister_device(&hc_conn, dev_addr);
     381
     382        usb_hc_connection_close(&hc_conn);
    363383
    364384        return rc;
Note: See TracChangeset for help on using the changeset viewer.