Changes in / [9a2923d:889e8e3] in mainline


Ignore:
Files:
20 added
19 deleted
19 edited

Legend:

Unmodified
Added
Removed

  • boot/arch/amd64/Makefile.inc

    r9a2923d r889e8e3  
    4949        usbflbk \
    5050        usbhub \
    51         usbkbd \
     51        usbhid \
    5252        usbmid \
    5353        usbmouse \

  • kernel/generic/src/mm/as.c

    r9a2923d r889e8e3  
    19491949sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
    19501950{
    1951         if (as_area_create(AS, flags, size, address,
     1951        if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
    19521952            AS_AREA_ATTR_NONE, &anon_backend, NULL))
    19531953                return (sysarg_t) address;

  • uspace/Makefile

    r9a2923d r889e8e3  
    122122                drv/uhci-rhd \
    123123                drv/usbflbk \
    124                 drv/usbkbd \
     124                drv/usbhid \
    125125                drv/usbhub \
    126126                drv/usbmid \
    … …  
    142142                drv/uhci-rhd \
    143143                drv/usbflbk \
    144                 drv/usbkbd \
     144                drv/usbhid \
    145145                drv/usbhub \
    146146                drv/usbmid \

  • uspace/drv/ohci/batch.c

    r9a2923d r889e8e3  
    118118        instance->next_step = batch_call_in_and_dispose;
    119119        /* TODO: implement */
    120         usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
     120        usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
    121121}
    122122/*----------------------------------------------------------------------------*/

  • uspace/drv/ohci/root_hub.c

    r9a2923d r889e8e3  
    3939
    4040#include "root_hub.h"
    41 #include "usb/classes/classes.h"
    42 #include <usb/request.h>
    43 #include <usb/classes/hub.h>
    44 
    4541
    4642/** Root hub initialization
    … …  
    5450        instance->device = dev;
    5551
    56 
    5752        usb_log_info("OHCI root hub with %d ports.\n", regs->rh_desc_a & 0xff);
    5853
    59         //start generic usb hub driver
    60        
    6154        /* TODO: implement */
    6255        return EOK;
    6356}
    6457/*----------------------------------------------------------------------------*/
    65 
    66 
    67 static int process_get_port_status_request(rh_t *instance, uint16_t port,
    68                 usb_transfer_batch_t * request){
    69         if(port<1 || port>instance->port_count)
    70                 return EINVAL;
    71         uint32_t * uint32_buffer = (uint32_t*)request->buffer;
    72         request->transfered_size = 4;
    73         uint32_buffer[0] = instance->registers->rh_port_status[port -1];
    74         return EOK;
    75 }
    76 
    77 static int process_get_hub_status_request(rh_t *instance,
    78                 usb_transfer_batch_t * request){
    79         uint32_t * uint32_buffer = (uint32_t*)request->buffer;
    80         //bits, 0,1,16,17
    81         request->transfered_size = 4;
    82         uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17);
    83         uint32_buffer[0] = mask & instance->registers->rh_status;
    84         return EOK;
    85 
    86 }
    87 
    88 static void usb_create_serialized_hub_descriptor(rh_t *instance, uint8_t ** out_result,
    89                 size_t * out_size) {
    90         //base size
    91         size_t size = 7;
    92         //variable size according to port count
    93         size_t var_size = instance->port_count / 8 +
    94                         ((instance->port_count % 8 > 0) ? 1 : 0);
    95         size += 2 * var_size;
    96         uint8_t * result = (uint8_t*) malloc(size);
    97         bzero(result,size);
    98         //size
    99         result[0] = size;
    100         //descriptor type
    101         result[1] = USB_DESCTYPE_HUB;
    102         result[2] = instance->port_count;
    103         uint32_t hub_desc_reg = instance->registers->rh_desc_a;
    104         result[3] =
    105                         ((hub_desc_reg >> 8) %2) +
    106                         (((hub_desc_reg >> 9) %2) << 1) +
    107                         (((hub_desc_reg >> 10) %2) << 2) +
    108                         (((hub_desc_reg >> 11) %2) << 3) +
    109                         (((hub_desc_reg >> 12) %2) << 4);
    110         result[4] = 0;
    111         result[5] = /*descriptor->pwr_on_2_good_time*/ 50;
    112         result[6] = 50;
    113 
    114         int port;
    115         for (port = 1; port <= instance->port_count; ++port) {
    116                 result[7 + port/8] +=
    117                                 ((instance->registers->rh_desc_b >> port)%2) << (port%8);
    118         }
    119         size_t i;
    120         for (i = 0; i < var_size; ++i) {
    121                 result[7 + var_size + i] = 255;
    122         }
    123         (*out_result) = result;
    124         (*out_size) = size;
    125 }
    126 
    127 
    128 static int process_get_status_request(rh_t *instance,
    129                 usb_transfer_batch_t * request)
    130 {
    131         size_t buffer_size = request->buffer_size;
    132         usb_device_request_setup_packet_t * request_packet =
    133                         (usb_device_request_setup_packet_t*)
    134                         request->setup_buffer;
    135 
    136         usb_hub_bm_request_type_t request_type = request_packet->request_type;
    137         if(buffer_size<4/*request_packet->length*/){///\TODO
    138                 usb_log_warning("requested more data than buffer size\n");
    139                 return EINVAL;
    140         }
    141 
    142         if(request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
    143                 return process_get_hub_status_request(instance, request);
    144         if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
    145                 return process_get_port_status_request(instance, request_packet->index,
    146                                 request);
    147         return ENOTSUP;
    148 }
    149 
    150 static void create_interrupt_mask(rh_t *instance, void ** buffer,
    151                 size_t * buffer_size){
    152         int bit_count = instance->port_count + 1;
    153         (*buffer_size) = (bit_count / 8) + (bit_count%8==0)?0:1;
    154         (*buffer) = malloc(*buffer_size);
    155         uint8_t * bitmap = (uint8_t*)(*buffer);
    156         uint32_t mask = (1<<16) + (1<<17);
    157         bzero(bitmap,(*buffer_size));
    158         if(instance->registers->rh_status & mask){
    159                 bitmap[0] = 1;
    160         }
    161         int port;
    162         mask = 0;
    163         int i;
    164         for(i=16;i<=20;++i)
    165                 mask += 1<<i;
    166         for(port = 1; port<=instance->port_count;++port){
    167                 if(mask & instance->registers->rh_port_status[port-1]){
    168                         bitmap[(port+1)/8] += 1<<(port%8);
    169                 }
    170         }
    171 }
    172 
    173 
    174 static int process_get_descriptor_request(rh_t *instance,
    175                 usb_transfer_batch_t *request){
    176         /// \TODO
    177         usb_device_request_setup_packet_t * setup_request =
    178                         (usb_device_request_setup_packet_t*)request->setup_buffer;
    179         size_t size;
    180         void * result_descriptor;
    181         uint16_t setup_request_value = setup_request->value_high;
    182                         //(setup_request->value_low << 8);
    183         if(setup_request_value == USB_DESCTYPE_HUB){
    184                 usb_log_debug("USB_DESCTYPE_HUB\n");
    185                 //create hub descriptor
    186                 uint8_t * descriptor;
    187                 usb_create_serialized_hub_descriptor(instance,
    188                                 &descriptor, &size);
    189                 result_descriptor = descriptor;
    190         }else if(setup_request_value == USB_DESCTYPE_DEVICE){
    191                 //create std device descriptor
    192                 usb_log_debug("USB_DESCTYPE_DEVICE\n");
    193                 usb_standard_device_descriptor_t * descriptor =
    194                                 (usb_standard_device_descriptor_t*)
    195                                 malloc(sizeof(usb_standard_device_descriptor_t));
    196                 descriptor->configuration_count = 1;
    197                 descriptor->descriptor_type = USB_DESCTYPE_DEVICE;
    198                 descriptor->device_class = USB_CLASS_HUB;
    199                 descriptor->device_protocol = 0;
    200                 descriptor->device_subclass = 0;
    201                 descriptor->device_version = 0;
    202                 descriptor->length = sizeof(usb_standard_device_descriptor_t);
    203                 /// \TODO this value is guessed
    204                 descriptor->max_packet_size = 8;
    205                 descriptor->product_id = 0x0001;
    206                 /// \TODO these values migt be different
    207                 descriptor->str_serial_number = 0;
    208                 descriptor->str_serial_number = 0;
    209                 descriptor->usb_spec_version = 0;
    210                 descriptor->vendor_id = 0x16db;
    211                 result_descriptor = descriptor;
    212                 size = sizeof(usb_standard_device_descriptor_t);
    213         }else if(setup_request_value == USB_DESCTYPE_CONFIGURATION){
    214                 usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
    215                 usb_standard_configuration_descriptor_t * descriptor =
    216                                 (usb_standard_configuration_descriptor_t*)
    217                                 malloc(sizeof(usb_standard_configuration_descriptor_t));
    218                 /// \TODO some values are default or guessed
    219                 descriptor->attributes = 1<<7;
    220                 descriptor->configuration_number = 1;
    221                 descriptor->descriptor_type = USB_DESCTYPE_CONFIGURATION;
    222                 descriptor->interface_count = 1;
    223                 descriptor->length = sizeof(usb_standard_configuration_descriptor_t);
    224                 descriptor->max_power = 100;
    225                 descriptor->str_configuration = 0;
    226                 /// \TODO should this include device descriptor?
    227                 size_t hub_descriptor_size = 7 +
    228                                 2* (instance->port_count / 8 +
    229                                 ((instance->port_count % 8 > 0) ? 1 : 0));
    230                 descriptor->total_length =
    231                                 sizeof(usb_standard_configuration_descriptor_t)+
    232                                 sizeof(usb_standard_endpoint_descriptor_t)+
    233                                 sizeof(usb_standard_interface_descriptor_t)+
    234                                 hub_descriptor_size;
    235                 result_descriptor = descriptor;
    236                 size = sizeof(usb_standard_configuration_descriptor_t);
    237 
    238         }else if(setup_request_value == USB_DESCTYPE_INTERFACE){
    239                 usb_log_debug("USB_DESCTYPE_INTERFACE\n");
    240                 usb_standard_interface_descriptor_t * descriptor =
    241                                 (usb_standard_interface_descriptor_t*)
    242                                 malloc(sizeof(usb_standard_interface_descriptor_t));
    243                 descriptor->alternate_setting = 0;
    244                 descriptor->descriptor_type = USB_DESCTYPE_INTERFACE;
    245                 descriptor->endpoint_count = 1;
    246                 descriptor->interface_class = USB_CLASS_HUB;
    247                 /// \TODO is this correct?
    248                 descriptor->interface_number = 1;
    249                 descriptor->interface_protocol = 0;
    250                 descriptor->interface_subclass = 0;
    251                 descriptor->length = sizeof(usb_standard_interface_descriptor_t);
    252                 descriptor->str_interface = 0;
    253                 result_descriptor = descriptor;
    254                 size = sizeof(usb_standard_interface_descriptor_t);
    255         }else if(setup_request_value == USB_DESCTYPE_ENDPOINT){
    256                 usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
    257                 usb_standard_endpoint_descriptor_t * descriptor =
    258                                 (usb_standard_endpoint_descriptor_t*)
    259                                 malloc(sizeof(usb_standard_endpoint_descriptor_t));
    260                 descriptor->attributes = USB_TRANSFER_INTERRUPT;
    261                 descriptor->descriptor_type = USB_DESCTYPE_ENDPOINT;
    262                 descriptor->endpoint_address = 1 + (1<<7);
    263                 descriptor->length = sizeof(usb_standard_endpoint_descriptor_t);
    264                 descriptor->max_packet_size = 8;
    265                 descriptor->poll_interval = 255;
    266                 result_descriptor = descriptor;
    267                 size = sizeof(usb_standard_endpoint_descriptor_t);
    268         }else{
    269                 usb_log_debug("USB_DESCTYPE_EINVAL %d \n",setup_request->value);
    270                 usb_log_debug("\ttype %d\n\trequest %d\n\tvalue %d\n\tindex %d\n\tlen %d\n ",
    271                                 setup_request->request_type,
    272                                 setup_request->request,
    273                                 setup_request_value,
    274                                 setup_request->index,
    275                                 setup_request->length
    276                                 );
    277                 return EINVAL;
    278         }
    279         if(request->buffer_size < size){
    280                 size = request->buffer_size;
    281         }
    282         request->transfered_size = size;
    283         memcpy(request->buffer,result_descriptor,size);
    284         free(result_descriptor);
    285         return EOK;
    286 }
    287 
    288 static int process_get_configuration_request(rh_t *instance,
    289                 usb_transfer_batch_t *request){
    290         //set and get configuration requests do not have any meaning, only dummy
    291         //values are returned
    292         if(request->buffer_size != 1)
    293                 return EINVAL;
    294         request->buffer[0] = 1;
    295         request->transfered_size = 1;
    296         return EOK;
    297 }
    298 
    299 static int process_hub_feature_set_request(rh_t *instance,
    300                 uint16_t feature, bool enable){
    301         if(feature > USB_HUB_FEATURE_C_HUB_OVER_CURRENT)
    302                 return EINVAL;
    303         instance->registers->rh_status =
    304                         enable ?
    305                         (instance->registers->rh_status | (1<<feature))
    306                         :
    307                         (instance->registers->rh_status & (~(1<<feature)));
    308         /// \TODO any error?
    309         return EOK;
    310 }
    311 
    312 static int process_port_feature_set_request(rh_t *instance,
    313                 uint16_t feature, uint16_t port, bool enable){
    314         if(feature > USB_HUB_FEATURE_C_PORT_RESET)
    315                 return EINVAL;
    316         if(port<1 || port>instance->port_count)
    317                 return EINVAL;
    318         instance->registers->rh_port_status[port - 1] =
    319                         enable ?
    320                         (instance->registers->rh_port_status[port - 1] | (1<<feature))
    321                         :
    322                         (instance->registers->rh_port_status[port - 1] & (~(1<<feature)));
    323         /// \TODO any error?
    324         return EOK;
    325 }
    326 
    327 static int process_address_set_request(rh_t *instance,
    328                 uint16_t address){
    329         instance->address = address;
    330         return EOK;
    331 }
    332 
    333 static int process_request_with_output(rh_t *instance,
    334                 usb_transfer_batch_t *request){
    335         usb_device_request_setup_packet_t * setup_request =
    336                         (usb_device_request_setup_packet_t*)request->setup_buffer;
    337         if(setup_request->request == USB_DEVREQ_GET_STATUS){
    338                 usb_log_debug("USB_DEVREQ_GET_STATUS\n");
    339                 return process_get_status_request(instance, request);
    340         }
    341         if(setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){
    342                 usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n");
    343                 return process_get_descriptor_request(instance, request);
    344         }
    345         if(setup_request->request == USB_DEVREQ_GET_CONFIGURATION){
    346                 usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
    347                 return process_get_configuration_request(instance, request);
    348         }
    349         return ENOTSUP;
    350 }
    351 
    352 static int process_request_with_input(rh_t *instance,
    353                 usb_transfer_batch_t *request){
    354         usb_device_request_setup_packet_t * setup_request =
    355                         (usb_device_request_setup_packet_t*)request->setup_buffer;
    356         request->transfered_size = 0;
    357         if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){
    358                 return ENOTSUP;
    359         }
    360         if(setup_request->request == USB_DEVREQ_SET_CONFIGURATION){
    361                 //set and get configuration requests do not have any meaning,
    362                 //only dummy values are returned
    363                 return EOK;
    364         }
    365         return ENOTSUP;
    366 }
    367 
    368 
    369 static int process_request_without_data(rh_t *instance,
    370                 usb_transfer_batch_t *request){
    371         usb_device_request_setup_packet_t * setup_request =
    372                         (usb_device_request_setup_packet_t*)request->setup_buffer;
    373         request->transfered_size = 0;
    374         if(setup_request->request == USB_DEVREQ_CLEAR_FEATURE
    375                                 || setup_request->request == USB_DEVREQ_SET_FEATURE){
    376                 if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){
    377                         usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
    378                         return process_hub_feature_set_request(instance, setup_request->value,
    379                                         setup_request->request == USB_DEVREQ_SET_FEATURE);
    380                 }
    381                 if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
    382                         usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
    383                         return process_port_feature_set_request(instance, setup_request->value,
    384                                         setup_request->index,
    385                                         setup_request->request == USB_DEVREQ_SET_FEATURE);
    386                 }
    387                 usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",setup_request->request_type);
    388                 return EINVAL;
    389         }
    390         if(setup_request->request == USB_DEVREQ_SET_ADDRESS){
    391                 usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
    392                 return process_address_set_request(instance, setup_request->value);
    393         }
    394         usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",setup_request->request_type);
    395         return ENOTSUP;
    396 }
    397 
    398 
    399 /**
    400  *
    401  * @param instance
    402  * @param request
    403  * @return
    404  */
    40558int rh_request(rh_t *instance, usb_transfer_batch_t *request)
    40659{
    40760        assert(instance);
    40861        assert(request);
    409         int opResult;
    410         if(request->transfer_type == USB_TRANSFER_CONTROL){
    411                 if (request->setup_buffer) {
    412                         usb_log_info("Root hub got CTRL packet: %s.\n",
    413                                 usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
    414                         if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){
    415                                 usb_log_error("setup packet too small\n");
    416                                 return EINVAL;
    417                         }
    418                         usb_device_request_setup_packet_t * setup_request =
    419                                         (usb_device_request_setup_packet_t*)request->setup_buffer;
    420                         if(
    421                                 setup_request->request == USB_DEVREQ_GET_STATUS
    422                                 || setup_request->request == USB_DEVREQ_GET_DESCRIPTOR
    423                                 || setup_request->request == USB_DEVREQ_GET_CONFIGURATION
    424                         ){
    425                                 usb_log_debug("processing request with output\n");
    426                                 opResult = process_request_with_output(instance,request);
    427                         }else if(
    428                                 setup_request->request == USB_DEVREQ_CLEAR_FEATURE
    429                                 || setup_request->request == USB_DEVREQ_SET_FEATURE
    430                                 || setup_request->request == USB_DEVREQ_SET_ADDRESS
    431                         ){
    432                                 usb_log_debug("processing request without additional data\n");
    433                                 opResult = process_request_without_data(instance,request);
    434                         }else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR
    435                                         || setup_request->request == USB_DEVREQ_SET_CONFIGURATION
    436                         ){
    437                                 usb_log_debug("processing request with input\n");
    438                                 opResult = process_request_with_input(instance,request);
    439                         }else{
    440                                 usb_log_warning("received unsuported request: %d\n",
    441                                                 setup_request->request
    442                                                 );
    443                                 opResult = ENOTSUP;
    444                         }
    445                 }else{
    446                         usb_log_error("root hub received empty transaction?");
    447                         opResult = EINVAL;
    448                 }
    449         }else if(request->transfer_type == USB_TRANSFER_INTERRUPT){
    450                 usb_log_info("Root hub got INTERRUPT packet\n");
    451                 void * buffer;
    452                 create_interrupt_mask(instance, &buffer,
    453                         &(request->transfered_size));
    454                 memcpy(request->transport_buffer,buffer, request->transfered_size);
    455                 opResult = EOK;
    456         }else{
    457                 opResult = EINVAL;
     62        /* TODO: implement */
     63        if (request->setup_buffer) {
     64                usb_log_info("Root hub got SETUP packet: %s.\n",
     65                    usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
    45866        }
    459         usb_transfer_batch_finish(request, opResult);
     67        usb_log_error("Root hub request processing not implemented.\n");
     68        usb_transfer_batch_finish(request, ENOTSUP);
    46069        return EOK;
    46170}
    46271/*----------------------------------------------------------------------------*/
    463 
    464 
    46572void rh_interrupt(rh_t *instance)
    46673{

  • uspace/drv/ohci/root_hub.h

    r9a2923d r889e8e3  
    4545        usb_address_t address;
    4646        ddf_dev_t *device;
    47         int port_count;
    4847} rh_t;
    4948

  • uspace/drv/uhci-hcd/Makefile

    r9a2923d r889e8e3  
    4040        root_hub.c \
    4141        hw_struct/transfer_descriptor.c \
    42         utils/slab.c \
    4342        pci.c \
    4443        batch.c

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

    r9a2923d r889e8e3  
    223223        ret = instance ? EOK : ENOMEM;
    224224        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to get frame list page.\n");
    225         usb_log_debug("Initialized frame list at %p.\n", instance->frame_list);
     225        usb_log_debug("Initialized frame list.\n");
    226226
    227227        /* Set all frames to point to the first queue head */
    … …  
    336336            instance->transfers[batch->speed][batch->transfer_type];
    337337        assert(list);
    338         if (batch->transfer_type == USB_TRANSFER_CONTROL) {
    339                 usb_device_keeper_use_control(
    340                     &instance->manager, batch->target.address);
    341         }
    342338        transfer_list_add_batch(list, batch);
    343339
    … …  
    361357        /* Lower 2 bits are transaction error and transaction complete */
    362358        if (status & 0x3) {
    363                 LIST_INITIALIZE(done);
    364                 transfer_list_remove_finished(
    365                     &instance->transfers_interrupt, &done);
    366                 transfer_list_remove_finished(
    367                     &instance->transfers_control_slow, &done);
    368                 transfer_list_remove_finished(
    369                     &instance->transfers_control_full, &done);
    370                 transfer_list_remove_finished(
    371                     &instance->transfers_bulk_full, &done);
    372 
    373                 while (!list_empty(&done)) {
    374                         link_t *item = done.next;
    375                         list_remove(item);
    376                         usb_transfer_batch_t *batch =
    377                             list_get_instance(item, usb_transfer_batch_t, link);
    378                         if (batch->transfer_type == USB_TRANSFER_CONTROL) {
    379                                 usb_device_keeper_release_control(
    380                                     &instance->manager, batch->target.address);
    381                         }
    382                         batch->next_step(batch);
    383                 }
     359                transfer_list_remove_finished(&instance->transfers_interrupt);
     360                transfer_list_remove_finished(&instance->transfers_control_slow);
     361                transfer_list_remove_finished(&instance->transfers_control_full);
     362                transfer_list_remove_finished(&instance->transfers_bulk_full);
    384363        }
    385364        /* bits 4 and 5 indicate hc error */

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

    r9a2923d r889e8e3  
    5858        }
    5959        instance->queue_head_pa = addr_to_phys(instance->queue_head);
    60         usb_log_debug2("Transfer list %s setup with QH: %p(%p).\n",
    61             name, instance->queue_head, instance->queue_head_pa);
    6260
    6361        qh_init(instance->queue_head);
    … …  
    120118        qh_set_next_qh(last_qh, pa);
    121119
    122         asm volatile ("": : :"memory");
    123 
    124120        /* Add to the driver list */
    125121        list_append(&batch->link, &instance->batch_list);
    … …  
    141137 * this transfer list leading to the deadlock if its done inline.
    142138 */
    143 void transfer_list_remove_finished(transfer_list_t *instance, link_t *done)
    144 {
    145         assert(instance);
    146         assert(done);
     139void transfer_list_remove_finished(transfer_list_t *instance)
     140{
     141        assert(instance);
     142
     143        LIST_INITIALIZE(done);
    147144
    148145        fibril_mutex_lock(&instance->guard);
    … …  
    156153                        /* Save for post-processing */
    157154                        transfer_list_remove_batch(instance, batch);
    158                         list_append(current, done);
     155                        list_append(current, &done);
    159156                }
    160157                current = next;
    … …  
    162159        fibril_mutex_unlock(&instance->guard);
    163160
     161        while (!list_empty(&done)) {
     162                link_t *item = done.next;
     163                list_remove(item);
     164                usb_transfer_batch_t *batch =
     165                    list_get_instance(item, usb_transfer_batch_t, link);
     166                batch->next_step(batch);
     167        }
    164168}
    165169/*----------------------------------------------------------------------------*/
    … …  
    218222                qpos = "NOT FIRST";
    219223        }
    220         asm volatile ("": : :"memory");
    221224        /* Remove from the batch list */
    222225        list_remove(&batch->link);

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

    r9a2923d r889e8e3  
    6767void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch);
    6868
    69 void transfer_list_remove_finished(transfer_list_t *instance, link_t *done);
     69void transfer_list_remove_finished(transfer_list_t *instance);
    7070
    7171void transfer_list_abort_all(transfer_list_t *instance);

  • uspace/drv/uhci-hcd/utils/malloc32.h

    r9a2923d r889e8e3  
    4040#include <as.h>
    4141
    42 #include "slab.h"
    43 
    4442#define UHCI_STRCUTURES_ALIGNMENT 16
    4543#define UHCI_REQUIRED_PAGE_SIZE 4096
    46 
    4744
    4845/** Get physical address translation
    … …  
    5754
    5855        uintptr_t result;
    59         const int ret = as_get_physical_mapping(addr, &result);
    60         assert(ret == EOK);
     56        int ret = as_get_physical_mapping(addr, &result);
    6157
    6258        if (ret != EOK)
    … …  
    7066 * @return Address of the alligned and big enough memory place, NULL on failure.
    7167 */
    72 static inline void * malloc32(size_t size) {
    73         if (size <= SLAB_ELEMENT_SIZE)
    74                 return slab_malloc_g();
    75         assert(false);
    76         return memalign(UHCI_STRCUTURES_ALIGNMENT, size);
    77 }
     68static inline void * malloc32(size_t size)
     69        { return memalign(UHCI_STRCUTURES_ALIGNMENT, size); }
    7870/*----------------------------------------------------------------------------*/
    7971/** Physical mallocator simulator
    … …  
    8173 * @param[in] addr Address of the place allocated by malloc32
    8274 */
    83 static inline void free32(void *addr) {
    84         if (!addr)
    85                 return;
    86         if (slab_in_range_g(addr))
    87                 return slab_free_g(addr);
    88         free(addr);
    89 }
     75static inline void free32(void *addr)
     76        { if (addr) free(addr); }
    9077/*----------------------------------------------------------------------------*/
    9178/** Create 4KB page mapping
    … …  
    9582static inline void * get_page(void)
    9683{
    97         void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
    98         assert(free_address); /* TODO: remove this assert */
     84        void * free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
     85        assert(free_address);
    9986        if (free_address == 0)
    10087                return NULL;
    101         void *ret = as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
     88        void* ret =
     89          as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
    10290                  AS_AREA_READ | AS_AREA_WRITE);
    10391        if (ret != free_address)

  • uspace/drv/usbhub/port_status.h

    r9a2923d r889e8e3  
    3030 */
    3131
    32 #ifndef HUB_PORT_STATUS_H
    33 #define HUB_PORT_STATUS_H
     32#ifndef PORT_STATUS_H
     33#define PORT_STATUS_H
    3434
    3535#include <bool.h>
    … …  
    335335
    336336
    337 #endif  /* HUB_PORT_STATUS_H */
     337#endif  /* PORT_STATUS_H */
    338338
    339339/**

  • uspace/drv/usbhub/usbhub.c

    r9a2923d r889e8e3  
    162162            std_descriptor->configuration_count);
    163163        if(std_descriptor->configuration_count<1){
    164                 usb_log_error("there are no configurations available\n");
     164                usb_log_error("THERE ARE NO CONFIGURATIONS AVAILABLE\n");
     165                //shouldn`t I return?
     166                //definitely
    165167                return EINVAL;
    166168        }

  • uspace/lib/c/generic/malloc.c

    r9a2923d r889e8e3  
    240240        size_t asize = ALIGN_UP(size, PAGE_SIZE);
    241241       
    242         astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
     242        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ);
    243243        if (astart == (void *) -1)
    244244                return false;

  • uspace/lib/usb/Makefile

    r9a2923d r889e8e3  
    5050        src/usb.c \
    5151        src/usbdevice.c \
    52         src/hidreq.c \
    53         src/hidreport.c \
    5452        src/host/device_keeper.c \
    5553        src/host/batch.c

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

    r9a2923d r889e8e3  
    7070 * Description of path of usage pages and usages in report descriptor
    7171 */
    72 #define USB_HID_PATH_COMPARE_STRICT                             0
    73 #define USB_HID_PATH_COMPARE_END                                1
    74 #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    4
    75 
    7672typedef struct {
    7773        int32_t usage_page;
    78         int32_t usage;
    79 
    80         link_t link;
    81 } usb_hid_report_usage_path_t;
    82 
    83 typedef struct {
    84         int depth;     
    85         link_t link;
    8674} usb_hid_report_path_t;
    8775
    … …  
    9179typedef struct {
    9280        int32_t id;
     81        int32_t usage_page;
     82        int32_t usage; 
    9383        int32_t usage_minimum;
    9484        int32_t usage_maximum;
    … …  
    117107        uint8_t item_flags;
    118108
    119         usb_hid_report_path_t *usage_path;
    120109        link_t link;
    121110} usb_hid_report_item_t;
    … …  
    128117        link_t feature;
    129118} usb_hid_report_parser_t;     
     119
    130120
    131121
    … …  
    204194int usb_hid_parse_report(const usb_hid_report_parser_t *parser, 
    205195    const uint8_t *data, size_t size,
    206     usb_hid_report_path_t *path, int flags,
    207196    const usb_hid_report_in_callbacks_t *callbacks, void *arg);
    208197
    209198int usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
    210         usb_hid_report_path_t *path, int flags);
     199        const usb_hid_report_path_t *path);
    211200
    212201
    … …  
    215204void usb_hid_descriptor_print(usb_hid_report_parser_t *parser);
    216205
    217 /* usage path functions */
    218 usb_hid_report_path_t *usb_hid_report_path(void);
    219 void usb_hid_report_path_free(usb_hid_report_path_t *path);
    220 int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, int32_t usage_page, int32_t usage);
    221 void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path);
    222 void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path);
    223 void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data);
    224 int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, usb_hid_report_path_t *path, int flags);
    225 int     usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path);
    226 
    227 
    228 // output
    229 //      - funkce co vrati cesty poli v output reportu
    230 //      - funkce co pro danou cestu nastavi data
    231 //      - finalize
    232 
    233206#endif
    234207/**

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

    r9a2923d r889e8e3  
    5151        usb_speed_t speed;
    5252        bool occupied;
    53         bool control_used;
    5453        uint16_t toggle_status[2];
    5554        devman_handle_t handle;
    … …  
    6261        struct usb_device_info devices[USB_ADDRESS_COUNT];
    6362        fibril_mutex_t guard;
    64         fibril_condvar_t change;
     63        fibril_condvar_t default_address_occupied;
    6564        usb_address_t last_address;
    6665} usb_device_keeper_t;
    … …  
    9897    usb_address_t address);
    9998
    100 void usb_device_keeper_use_control(usb_device_keeper_t *instance,
    101     usb_address_t address);
    102 
    103 void usb_device_keeper_release_control(usb_device_keeper_t *instance,
    104     usb_address_t address);
    105 
    10699#endif
    107100/**

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

    r9a2923d r889e8e3  
    4747
    4848int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
    49                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
     49                             usb_hid_report_item_t *report_item);
    5050int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    51                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
     51                             usb_hid_report_item_t *report_item);
    5252int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    53                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
     53                             usb_hid_report_item_t *report_item);
    5454int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    55                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path);
     55                             usb_hid_report_item_t *report_item);
    5656
    5757void usb_hid_descriptor_print_list(link_t *head);
    … …  
    6363int usb_pow(int a, int b);
    6464
    65 
    6665int usb_pow(int a, int b)
    6766{
    … …  
    8584{
    8685   if(parser == NULL) {
    87         return EINVAL;
     86        return -1;
    8887   }
    8988
    … …  
    111110        int ret;
    112111        usb_hid_report_item_t *report_item=0;
    113         usb_hid_report_item_t *new_report_item;
    114         usb_hid_report_path_t *usage_path;
    115         usb_hid_report_path_t *tmp_usage_path;
     112        usb_hid_report_item_t *new_report_item;
    116113
    117114        size_t offset_input=0;
    … …  
    120117       
    121118
    122         /* parser structure initialization*/
    123         if(usb_hid_parser_init(parser) != EOK) {
    124                 return EINVAL;
    125         }
    126        
    127 
    128         /*report item initialization*/
    129119        if(!(report_item=malloc(sizeof(usb_hid_report_item_t)))){
    130120                return ENOMEM;
    131121        }
    132122        memset(report_item, 0, sizeof(usb_hid_report_item_t));
    133         list_initialize(&(report_item->link)); 
    134 
    135         /* usage path context initialization */
    136         if(!(usage_path=usb_hid_report_path())){
    137                 return ENOMEM;
    138         }
    139        
     123       
     124        link_initialize(&(report_item->link)); 
     125
    140126        while(i<size){ 
    141127                if(!USB_HID_ITEM_IS_LONG(data[i])){
    142128
    143129                        if((i+USB_HID_ITEM_SIZE(data[i]))>= size){
    144                                 return EINVAL; // TODO ERROR CODE
     130                                return -1; // TODO ERROR CODE
    145131                        }
    146132                       
    … …  
    155141                       
    156142                        ret = usb_hid_report_parse_tag(tag,class,data+i+1,
    157                                                        item_size,report_item, usage_path);
     143                                                 item_size,report_item);
    158144                        usb_log_debug2("ret: %u\n", ret);
    159145                        switch(ret){
    160146                                case USB_HID_NEW_REPORT_ITEM:
    161147                                        // store report item to report and create the new one
    162                                         usb_log_debug("\nNEW REPORT ITEM: %X",ret);
    163 
    164                                         // store current usage path
    165                                         report_item->usage_path = usage_path;
    166 
    167                                         // new current usage path
    168                                         tmp_usage_path = usb_hid_report_path();
    169                                        
    170                                         // copy old path to the new one
    171                                         usb_hid_report_path_clone(tmp_usage_path, usage_path);
    172 
    173                                         // swap
    174                                         usage_path = tmp_usage_path;
    175                                         tmp_usage_path = NULL;
    176 
     148                                        usb_log_debug("\nNEW REPORT ITEM: %X",tag);
    177149                                       
    178150                                        switch(tag) {
    … …  
    212184                                        link_initialize(&(new_report_item->link));
    213185                                        report_item = new_report_item;
    214                                                                                
     186                                       
    215187                                        break;
    216188                                case USB_HID_REPORT_TAG_PUSH:
    … …  
    312284 */
    313285int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size,
    314                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
     286                             usb_hid_report_item_t *report_item)
    315287{       
    316288        int ret;
    … …  
    319291                case USB_HID_TAG_CLASS_MAIN:
    320292
    321                         if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item, usage_path)) == EOK) {
     293                        if((ret=usb_hid_report_parse_main_tag(tag,data,item_size,report_item)) == EOK) {
    322294                                return USB_HID_NEW_REPORT_ITEM;
    323295                        }
    … …  
    329301
    330302                case USB_HID_TAG_CLASS_GLOBAL: 
    331                         return usb_hid_report_parse_global_tag(tag,data,item_size,report_item, usage_path);
     303                        return usb_hid_report_parse_global_tag(tag,data,item_size,report_item);
    332304                        break;
    333305
    334306                case USB_HID_TAG_CLASS_LOCAL:                   
    335                         return usb_hid_report_parse_local_tag(tag,data,item_size,report_item, usage_path);
     307                        return usb_hid_report_parse_local_tag(tag,data,item_size,report_item);
    336308                        break;
    337309                default:
    … …  
    351323
    352324int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    353                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
    354 {               
     325                             usb_hid_report_item_t *report_item)
     326{
    355327        switch(tag)
    356328        {
    … …  
    363335                       
    364336                case USB_HID_REPORT_TAG_COLLECTION:
    365                         usb_hid_report_path_append_item(usage_path, 0, 0);
    366                                                
     337                        // TODO
    367338                        return USB_HID_NO_ACTION;
    368339                        break;
    369340                       
    370341                case USB_HID_REPORT_TAG_END_COLLECTION:
    371                         // TODO
    372                         // znici posledni uroven ve vsech usage paths
    373                         // otazka jestli nema nicit dve, respektive novou posledni vynulovat?
    374                         usb_hid_report_remove_last_item(usage_path);
     342                        /* should be ignored */
    375343                        return USB_HID_NO_ACTION;
    376344                        break;
    … …  
    393361
    394362int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    395                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
     363                             usb_hid_report_item_t *report_item)
    396364{
    397365        // TODO take care about the bit length of data
    … …  
    399367        {
    400368                case USB_HID_REPORT_TAG_USAGE_PAGE:
    401                         // zmeni to jenom v poslednim poli aktualni usage path
    402                         usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL,
    403                                 usb_hid_report_tag_data_int32(data,item_size));
     369                        report_item->usage_page = usb_hid_report_tag_data_int32(data,item_size);
    404370                        break;
    405371                case USB_HID_REPORT_TAG_LOGICAL_MINIMUM:
    … …  
    452418 */
    453419int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    454                              usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
     420                             usb_hid_report_item_t *report_item)
    455421{
    456422        switch(tag)
    457423        {
    458424                case USB_HID_REPORT_TAG_USAGE:
    459                         usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL,
    460                                 usb_hid_report_tag_data_int32(data,item_size));
     425                        report_item->usage = usb_hid_report_tag_data_int32(data,item_size);
    461426                        break;
    462427                case USB_HID_REPORT_TAG_USAGE_MINIMUM:
    … …  
    526491{
    527492        usb_hid_report_item_t *report_item;
    528         usb_hid_report_usage_path_t *path_item;
    529         link_t *path;
    530493        link_t *item;
    531494       
    … …  
    544507                usb_log_debug("\tCONSTANT/VAR: %X\n", USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags));
    545508                usb_log_debug("\tVARIABLE/ARRAY: %X\n", USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags));
    546                 usb_log_debug("\tUSAGE PATH:\n");
    547 
    548                 path = report_item->usage_path->link.next;
    549                 while(path != &report_item->usage_path->link)   {
    550                         path_item = list_get_instance(path, usb_hid_report_usage_path_t, link);
    551                         usb_log_debug("\t\tUSAGE PAGE: %X, USAGE: %X\n", path_item->usage_page, path_item->usage);
    552                         path = path->next;
    553                 }
    554                
    555                
    556 //              usb_log_debug("\tUSAGE: %X\n", report_item->usage);
    557 //              usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page);
     509                usb_log_debug("\tUSAGE: %X\n", report_item->usage);
     510                usb_log_debug("\tUSAGE PAGE: %X\n", report_item->usage_page);
    558511                usb_log_debug("\tLOGMIN: %X\n", report_item->logical_minimum);
    559512                usb_log_debug("\tLOGMAX: %X\n", report_item->logical_maximum);         
    … …  
    577530void usb_hid_descriptor_print(usb_hid_report_parser_t *parser)
    578531{
    579         if(parser == NULL) {
    580                 return;
    581         }
    582        
    583532        usb_log_debug("INPUT:\n");
    584533        usb_hid_descriptor_print_list(&parser->input);
    … …  
    612561       
    613562            report_item = list_get_instance(next, usb_hid_report_item_t, link);
    614 
    615                 while(!list_empty(&report_item->usage_path->link)) {
    616                         usb_hid_report_remove_last_item(report_item->usage_path);
    617                 }
    618 
    619                
    620563            next = next->next;
    621564           
    … …  
    657600int usb_hid_parse_report(const usb_hid_report_parser_t *parser, 
    658601    const uint8_t *data, size_t size,
    659     usb_hid_report_path_t *path, int flags,
    660602    const usb_hid_report_in_callbacks_t *callbacks, void *arg)
    661603{
    … …  
    673615        size_t j=0;
    674616
    675         if(parser == NULL) {
    676                 return EINVAL;
    677         }
    678 
    679        
    680617        // get the size of result keycodes array
    681         key_count = usb_hid_report_input_length(parser, path, flags);
     618        usb_hid_report_path_t path;
     619        path.usage_page = BAD_HACK_USAGE_PAGE;
     620        key_count = usb_hid_report_input_length(parser, &path);
    682621
    683622        if(!(keys = malloc(sizeof(uint8_t) * key_count))){
    … …  
    690629
    691630                item = list_get_instance(list_item, usb_hid_report_item_t, link);
    692                 if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) && 
    693                    (usb_hid_report_compare_usage_path(item->usage_path, path, flags) == EOK)) {
     631                if(!USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) &&
     632                   (item->usage_page == path.usage_page)) {
    694633                        for(j=0; j<(size_t)(item->count); j++) {
    695634                                if((USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) ||
    … …  
    701640                                        // bitmapa
    702641                                        if((item_value = usb_hid_translate_data(item, data, j)) != 0) {
    703                                                 keys[i++] = (item->count - 1 - j) + item->usage_minimum;
     642                                                keys[i++] = j + item->usage_minimum;
    704643                                        }
    705644                                        else {
    … …  
    797736
    798737int usb_hid_report_input_length(const usb_hid_report_parser_t *parser,
    799         usb_hid_report_path_t *path, int flags)
    800 {       
     738        const usb_hid_report_path_t *path)
     739{
    801740        int ret = 0;
    802741        link_t *item;
    803742        usb_hid_report_item_t *report_item;
    804743
    805         if(parser == NULL) {
    806                 return EINVAL;
    807         }
    808        
    809744        item = (&parser->input)->next;
    810745        while(&parser->input != item) {
    811746                report_item = list_get_instance(item, usb_hid_report_item_t, link);
    812747                if(!USB_HID_ITEM_FLAG_CONSTANT(report_item->item_flags) &&
    813                    (usb_hid_report_compare_usage_path(report_item->usage_path, path, flags) == EOK)) {
     748                   (report_item->usage_page == path->usage_page)) {
    814749                        ret += report_item->count;
    815750                }
    … …  
    822757
    823758
    824 /**
    825  *
    826  */
    827 int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path,
    828                                     int32_t usage_page, int32_t usage)
    829 {       
    830         usb_hid_report_usage_path_t *item;
    831 
    832         if(!(item=malloc(sizeof(usb_hid_report_usage_path_t)))) {
    833                 return ENOMEM;
    834         }
    835         list_initialize(&item->link);
    836 
    837         item->usage = usage;
    838         item->usage_page = usage_page;
    839        
    840         list_append (&usage_path->link, &item->link);
    841         usage_path->depth++;
    842         return EOK;
    843 }
    844 
    845 /**
    846  *
    847  */
    848 void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path)
    849 {
    850         usb_hid_report_usage_path_t *item;
    851        
    852         if(!list_empty(&usage_path->link)){
    853                 item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);             
    854                 list_remove(usage_path->link.prev);
    855                 usage_path->depth--;
    856                 free(item);
    857         }
    858 }
    859 
    860 /**
    861  *
    862  */
    863 void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path)
    864 {
    865         usb_hid_report_usage_path_t *item;
    866        
    867         if(!list_empty(&usage_path->link)){     
    868                 item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);
    869                 memset(item, 0, sizeof(usb_hid_report_usage_path_t));
    870         }
    871 }
    872 
    873 /**
    874  *
    875  */
    876 void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, int32_t tag, int32_t data)
    877 {
    878         usb_hid_report_usage_path_t *item;
    879        
    880         if(!list_empty(&usage_path->link)){     
    881                 item = list_get_instance(usage_path->link.prev, usb_hid_report_usage_path_t, link);
    882 
    883                 switch(tag) {
    884                         case USB_HID_TAG_CLASS_GLOBAL:
    885                                 item->usage_page = data;
    886                                 break;
    887                         case USB_HID_TAG_CLASS_LOCAL:
    888                                 item->usage = data;
    889                                 break;
    890                 }
    891         }
    892        
    893 }
    894 
    895 /**
    896  *
    897  */
    898 int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path,
    899                                       usb_hid_report_path_t *path,
    900                                       int flags)
    901 {
    902         usb_hid_report_usage_path_t *report_item;
    903         usb_hid_report_usage_path_t *path_item;
    904 
    905         link_t *report_link;
    906         link_t *path_link;
    907 
    908         int only_page;
    909 
    910         if(path->depth == 0){
    911                 return EOK;
    912         }
    913 
    914 
    915         if((only_page = flags & USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY) != 0){
    916                 flags -= USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY;
    917         }
    918        
    919         switch(flags){
    920                 /* path must be completly identical */
    921                 case USB_HID_PATH_COMPARE_STRICT:
    922                                 if(report_path->depth != path->depth){
    923                                         return 1;
    924                                 }
    925 
    926                                 report_link = report_path->link.next;
    927                                 path_link = path->link.next;
    928                        
    929                                 while((report_link != &report_path->link) && (path_link != &path->link)) {
    930                                         report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
    931                                         path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);           
    932 
    933                                         if((report_item->usage_page != path_item->usage_page) ||
    934                                            ((only_page == 0) && (report_item->usage != path_item->usage))) {
    935                                                    return 1;
    936                                         } else {
    937                                                 report_link = report_link->next;
    938                                                 path_link = path_link->next;                   
    939                                         }
    940                        
    941                                 }
    942 
    943                                 if((report_link == &report_path->link) && (path_link == &path->link)) {
    944                                         return EOK;
    945                                 }
    946                                 else {
    947                                         return 1;
    948                                 }                                               
    949                         break;
    950 
    951                 /* given path must be the end of the report one*/
    952                 case USB_HID_PATH_COMPARE_END:
    953                                 report_link = report_path->link.prev;
    954                                 path_link = path->link.prev;
    955 
    956                                 if(list_empty(&path->link)){
    957                                         return EOK;
    958                                 }
    959                        
    960                                 while((report_link != &report_path->link) && (path_link != &path->link)) {
    961                                         report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
    962                                         path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);           
    963 
    964                                         if((report_item->usage_page != path_item->usage_page) ||
    965                                            ((only_page == 0) && (report_item->usage != path_item->usage))) {
    966                                                    return 1;
    967                                         } else {
    968                                                 report_link = report_link->prev;
    969                                                 path_link = path_link->prev;                   
    970                                         }
    971                        
    972                                 }
    973 
    974                                 if(path_link == &path->link) {
    975                                         return EOK;
    976                                 }
    977                                 else {
    978                                         return 1;
    979                                 }                                               
    980                        
    981                         break;
    982 
    983                 default:
    984                         return EINVAL;
    985         }
    986        
    987        
    988        
    989        
    990 }
    991 
    992 /**
    993  *
    994  */
    995 usb_hid_report_path_t *usb_hid_report_path(void)
    996 {
    997         usb_hid_report_path_t *path;
    998         path = malloc(sizeof(usb_hid_report_path_t));
    999         if(!path){
    1000                 return NULL;
    1001         }
    1002         else {
    1003                 path->depth = 0;
    1004                 list_initialize(&path->link);
    1005                 return path;
    1006         }
    1007 }
    1008 
    1009 /**
    1010  *
    1011  */
    1012 void usb_hid_report_path_free(usb_hid_report_path_t *path)
    1013 {
    1014         while(!list_empty(&path->link)){
    1015                 usb_hid_report_remove_last_item(path);
    1016         }
    1017 }
    1018 
    1019 
    1020 /**
    1021  *
    1022  */
    1023 int     usb_hid_report_path_clone(usb_hid_report_path_t *new_usage_path, usb_hid_report_path_t *usage_path)
    1024 {
    1025         usb_hid_report_usage_path_t *path_item;
    1026         link_t *path_link;
    1027 
    1028        
    1029         if(list_empty(&usage_path->link)){
    1030                 return EOK;
    1031         }
    1032 
    1033         path_link = usage_path->link.next;
    1034         while(path_link != &usage_path->link) {
    1035                 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);
    1036                 usb_hid_report_path_append_item (new_usage_path, path_item->usage_page, path_item->usage);
    1037 
    1038                 path_link = path_link->next;
    1039         }
    1040 
    1041         return EOK;
    1042 }
    1043 
    1044759
    1045760/**

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

    r9a2923d r889e8e3  
    4949        assert(instance);
    5050        fibril_mutex_initialize(&instance->guard);
    51         fibril_condvar_initialize(&instance->change);
     51        fibril_condvar_initialize(&instance->default_address_occupied);
    5252        instance->last_address = 0;
    5353        unsigned i = 0;
    5454        for (; i < USB_ADDRESS_COUNT; ++i) {
    5555                instance->devices[i].occupied = false;
    56                 instance->devices[i].control_used = false;
    5756                instance->devices[i].handle = 0;
    5857                instance->devices[i].toggle_status[0] = 0;
    … …  
    7271        fibril_mutex_lock(&instance->guard);
    7372        while (instance->devices[USB_ADDRESS_DEFAULT].occupied) {
    74                 fibril_condvar_wait(&instance->change, &instance->guard);
     73                fibril_condvar_wait(&instance->default_address_occupied,
     74                    &instance->guard);
    7575        }
    7676        instance->devices[USB_ADDRESS_DEFAULT].occupied = true;
    … …  
    9090        instance->devices[USB_ADDRESS_DEFAULT].occupied = false;
    9191        fibril_mutex_unlock(&instance->guard);
    92         fibril_condvar_signal(&instance->change);
     92        fibril_condvar_signal(&instance->default_address_occupied);
    9393}
    9494/*----------------------------------------------------------------------------*/
    … …  
    309309        return instance->devices[address].speed;
    310310}
    311 /*----------------------------------------------------------------------------*/
    312 void usb_device_keeper_use_control(usb_device_keeper_t *instance,
    313     usb_address_t address)
    314 {
    315         assert(instance);
    316         fibril_mutex_lock(&instance->guard);
    317         while (instance->devices[address].control_used) {
    318                 fibril_condvar_wait(&instance->change, &instance->guard);
    319         }
    320         instance->devices[address].control_used = true;
    321         fibril_mutex_unlock(&instance->guard);
    322 }
    323 /*----------------------------------------------------------------------------*/
    324 void usb_device_keeper_release_control(usb_device_keeper_t *instance,
    325     usb_address_t address)
    326 {
    327         assert(instance);
    328         fibril_mutex_lock(&instance->guard);
    329         instance->devices[address].control_used = false;
    330         fibril_mutex_unlock(&instance->guard);
    331         fibril_condvar_signal(&instance->change);
    332 }
     311
    333312/**
    334313 * @}
Note: See TracChangeset for help on using the changeset viewer.