Changes in / [ff76509:8fd4ba0] in mainline


Ignore:
Location:
uspace
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/root_hub.c

    rff76509 r8fd4ba0  
    198198static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request);
    199199
    200 static int process_interrupt(rh_t *instance, usb_transfer_batch_t * request,
    201     void * change_buffer, size_t buffe_size);
    202 
    203 static bool is_zeros(void * buffer, size_t size);
     200
    204201
    205202
    … …  
    216213        // set port power mode to no-power-switching
    217214        instance->registers->rh_desc_a |= RHDA_NPS_FLAG;
    218         instance->unfinished_interrupt_transfer = NULL;
     215
    219216        usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
    220217        return EOK;
    … …  
    239236                usb_log_info("Root hub got INTERRUPT packet\n");
    240237                void * buffer;
    241                 size_t buffer_size;
    242238                create_interrupt_mask(instance, &buffer,
    243                         &buffer_size);
    244                 if(is_zeros(buffer,buffer_size)){
    245                         usb_log_debug("no changes..");
    246                         instance->unfinished_interrupt_transfer=
    247                             request;
    248                         //will be finished later
    249                 }else{
    250                         usb_log_debug("processing changes..");
    251                         process_interrupt(instance, request,
    252                             buffer, buffer_size);
    253                 }
    254                 free(buffer);
     239                        &(request->transfered_size));
     240                memcpy(request->data_buffer, buffer,
     241                        request->transfered_size);
    255242                opResult = EOK;
    256243        } else {
    257244                opResult = EINVAL;
    258                 usb_transfer_batch_finish_error(request, opResult);
    259         }
     245        }
     246        usb_transfer_batch_finish_error(request, opResult);
    260247        return EOK;
    261248}
    … …  
    265252
    266253void rh_interrupt(rh_t *instance) {
    267         //usb_log_info("Whoa whoa wait, I`m not supposed to receive any "
    268         //      "interrupts, am I?\n");
    269         if(!instance->unfinished_interrupt_transfer){
    270                 return;
    271         }
    272         size_t size;
    273         void * buffer;
    274         create_interrupt_mask(instance, &buffer,
    275                         &size);
    276         process_interrupt(instance,instance->unfinished_interrupt_transfer,
    277             buffer,size);
    278         free(buffer);
     254        usb_log_info("Whoa whoa wait, I`m not supposed to receive any "
     255                "interrupts, am I?\n");
     256        /* TODO: implement? */
    279257}
    280258/*----------------------------------------------------------------------------*/
    … …  
    881859        return opResult;
    882860}
    883 /*----------------------------------------------------------------------------*/
    884 
    885 /**
    886  * process hanging interrupt request
    887  *
    888  * If an interrupt transfer has been received and there was no change,
    889  * the driver stores the transfer information and waits for change to occcur.
    890  * This routine is called when that happens and it finalizes the interrupt
    891  * transfer.
    892  *
    893  * @param instance hub instance
    894  * @param request batch request to be processed
    895  * @param change_buffer chages on hub
    896  * @param buffer_size size of change buffer
    897  *
    898  * @return
    899  */
    900 static int process_interrupt(rh_t *instance, usb_transfer_batch_t * request,
    901     void * change_buffer, size_t buffe_size){
    902         create_interrupt_mask(instance, &change_buffer,
    903             &(request->transfered_size));
    904         memcpy(request->data_buffer, change_buffer,request->transfered_size);
    905         instance->unfinished_interrupt_transfer = NULL;
    906         usb_transfer_batch_finish_error(request, EOK);
    907         return EOK;
    908 }
    909 
    910 /*----------------------------------------------------------------------------*/
    911 
    912 /**
    913  * return whether the buffer is full of zeros
    914  *
    915  * Convenience function.
    916  * @param buffer
    917  * @param size
    918  * @return
    919  */
    920 static bool is_zeros(void * buffer, size_t size){
    921         if(!buffer) return true;
    922         if(!size) return true;
    923         size_t i;
    924         for(i=0;i<size;++i){
    925                 if(((char*)buffer)[i])
    926                         return false;
    927         }
    928         return true;
    929 }
    930861
    931862/**

  • uspace/drv/ohci/root_hub.h

    rff76509 r8fd4ba0  
    5454        /** hubs descriptors */
    5555        usb_device_descriptors_t descriptors;
    56         /** interrupt transfer waiting for an actual interrupt to occur */
    57         usb_transfer_batch_t * unfinished_interrupt_transfer;
    5856} rh_t;
    5957

  • uspace/drv/usbhub/usbhub.c

    rff76509 r8fd4ba0  
    105105        }
    106106
    107         //usb_pipe_start_session(hub_info->control_pipe);
     107        usb_pipe_start_session(hub_info->control_pipe);
    108108        //set hub configuration
    109109        opResult = usb_hub_set_configuration(hub_info);
    … …  
    122122                return opResult;
    123123        }
    124         //usb_pipe_end_session(hub_info->control_pipe);
    125 
    126 
    127         usb_log_debug("Creating 'hub' function in DDF.\n");
     124        usb_pipe_end_session(hub_info->control_pipe);
     125
     126        /// \TODO what is this?
     127        usb_log_debug("Creating `hub' function.\n");
    128128        ddf_fun_t *hub_fun = ddf_fun_create(hub_info->usb_device->ddf_dev,
    129129            fun_exposed, "hub");
    … …  
    153153bool hub_port_changes_callback(usb_device_t *dev,
    154154    uint8_t *change_bitmap, size_t change_bitmap_size, void *arg) {
    155         usb_log_debug("hub_port_changes_callback\n");
    156155        usb_hub_info_t *hub = (usb_hub_info_t *) arg;
    157156
    … …  
    218217        // get hub descriptor
    219218        usb_log_debug("creating serialized descriptor\n");
    220         //void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE);
    221         uint8_t serialized_descriptor[USB_HUB_MAX_DESCRIPTOR_SIZE];
     219        void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE);
    222220        usb_hub_descriptor_t * descriptor;
    223221        int opResult;
    … …  
    237235        }
    238236        usb_log_debug2("deserializing descriptor\n");
    239         descriptor = usb_create_deserialized_hub_desriptor(
    240             serialized_descriptor);
     237        descriptor = usb_deserialize_hub_desriptor(serialized_descriptor);
    241238        if (descriptor == NULL) {
    242239                usb_log_warning("could not deserialize descriptor \n");
    243                 return ENOMEM;
     240                return opResult;
    244241        }
    245242        usb_log_debug("setting port count to %d\n", descriptor->ports_count);
    246243        hub_info->port_count = descriptor->ports_count;
    247244        /// \TODO this is not semantically correct
    248         bool is_power_switched =
    249             ((descriptor->hub_characteristics & 1) ==0);
    250         bool has_individual_port_powering =
    251             ((descriptor->hub_characteristics & 1) !=0);
    252245        hub_info->ports = malloc(
    253246            sizeof (usb_hub_port_t) * (hub_info->port_count + 1));
    … …  
    256249                usb_hub_port_init(&hub_info->ports[port]);
    257250        }
    258         if(is_power_switched){
    259                 usb_log_debug("is_power_switched\n");
    260                 if(has_individual_port_powering){
    261                         usb_log_debug("has_individual_port_powering\n");
    262                         for (port = 0; port < hub_info->port_count; port++) {
    263                                 opResult = usb_hub_set_port_feature(hub_info->control_pipe,
    264                                     port+1, USB_HUB_FEATURE_PORT_POWER);
    265                                 if (opResult != EOK) {
    266                                         usb_log_error("cannot power on port %d;  %d\n",
    267                                             port+1, opResult);
    268                                 }
    269                         }
    270                 }else{
    271                         usb_log_debug("!has_individual_port_powering\n");
    272                         opResult = usb_hub_set_feature(hub_info->control_pipe,
    273                             USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    274                         if (opResult != EOK) {
    275                                 usb_log_error("cannot power hub;  %d\n",
    276                                   opResult);
    277                         }
    278                 }
    279         }else{
    280                 usb_log_debug("!is_power_switched\n");
     251        for (port = 0; port < hub_info->port_count; port++) {
     252                opResult = usb_hub_set_port_feature(hub_info->control_pipe,
     253                    port+1, USB_HUB_FEATURE_PORT_POWER);
     254                if (opResult != EOK) {
     255                        usb_log_error("cannot power on port %d;  %d\n",
     256                            port+1, opResult);
     257                }
    281258        }
    282259        usb_log_debug2("freeing data\n");
    283         //free(serialized_descriptor);
    284         //free(descriptor->devices_removable);
     260        free(serialized_descriptor);
     261        free(descriptor->devices_removable);
    285262        free(descriptor);
    286263        return EOK;
    … …  
    344321         * auto destruction, this could work better.
    345322         */
    346         int rc = usb_hc_connection_open(&hub_info->connection);
     323        int rc = usb_pipe_start_session(hub_info->control_pipe);
    347324        if (rc != EOK) {
    348                 //usb_pipe_end_session(hub_info->control_pipe);
     325                usb_log_error("Failed to start session on control pipe: %s.\n",
     326                    str_error(rc));
     327                return rc;
     328        }
     329        rc = usb_hc_connection_open(&hub_info->connection);
     330        if (rc != EOK) {
     331                usb_pipe_end_session(hub_info->control_pipe);
    349332                usb_log_error("Failed to open connection to HC: %s.\n",
    350333                    str_error(rc));

  • uspace/drv/usbhub/usbhub_private.h

    rff76509 r8fd4ba0  
    113113
    114114        usb_device_request_setup_packet_t clear_request = {
    115                 .request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE,
     115                .request_type = USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE,
    116116                .request = USB_DEVREQ_SET_FEATURE,
    117117                .length = 0,
    … …  
    166166}
    167167
     168/**
     169 * create uint8_t array with serialized descriptor
     170 *
     171 * @param descriptor
     172 * @return newly created serializd descriptor pointer
     173 */
     174void * usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor);
    168175
    169 void * usb_create_serialized_hub_descriptor(usb_hub_descriptor_t * descriptor);
    170 
    171 void usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor,
    172     void * serialized_descriptor);
    173 
    174 usb_hub_descriptor_t * usb_create_deserialized_hub_desriptor(
    175     void * serialized_descriptor);
    176 
    177 void usb_deserialize_hub_desriptor(void * serialized_descriptor,
    178     usb_hub_descriptor_t * descriptor);
     176/**
     177 * create deserialized desriptor structure out of serialized descriptor
     178 *
     179 * The serialized descriptor must be proper usb hub descriptor,
     180 * otherwise an eerror might occur.
     181 *
     182 * @param sdescriptor serialized descriptor
     183 * @return newly created deserialized descriptor pointer
     184 */
     185usb_hub_descriptor_t * usb_deserialize_hub_desriptor(void * sdescriptor);
    179186
    180187

  • uspace/drv/usbhub/utils.c

    rff76509 r8fd4ba0  
    5656//hub descriptor utils
    5757
    58 /**
    59  * create uint8_t array with serialized descriptor
    60  *
    61  * @param descriptor
    62  * @return newly created serializd descriptor pointer
    63  */
    64 void * usb_create_serialized_hub_descriptor(usb_hub_descriptor_t * descriptor) {
     58void * usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor) {
    6559        //base size
    6660        size_t size = 7;
    … …  
    7064        uint8_t * result = malloc(size);
    7165        //size
    72         if(result)
    73                 usb_serialize_hub_descriptor(descriptor,result);
     66        result[0] = size;
     67        //descriptor type
     68        result[1] = USB_DESCTYPE_HUB;
     69        result[2] = descriptor->ports_count;
     70        /// @fixme handling of endianness??
     71        result[3] = descriptor->hub_characteristics / 256;
     72        result[4] = descriptor->hub_characteristics % 256;
     73        result[5] = descriptor->pwr_on_2_good_time;
     74        result[6] = descriptor->current_requirement;
     75
     76        size_t i;
     77        for (i = 0; i < var_size; ++i) {
     78                result[7 + i] = descriptor->devices_removable[i];
     79        }
     80        for (i = 0; i < var_size; ++i) {
     81                result[7 + var_size + i] = 255;
     82        }
    7483        return result;
    7584}
    7685
    77 /**
    78  * serialize descriptor into given buffer
    79  *
    80  * The buffer size is not checked.
    81  * @param descriptor
    82  * @param serialized_descriptor
    83  */
    84 void usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor,
    85     void * serialized_descriptor) {
    86         //base size
    87         uint8_t * sdescriptor = serialized_descriptor;
    88         size_t size = 7;
    89         //variable size according to port count
    90         size_t var_size = (descriptor->ports_count+7)/8;
    91         size += 2 * var_size;
    92         //size
    93         sdescriptor[0] = size;
    94         //descriptor type
    95         sdescriptor[1] = USB_DESCTYPE_HUB;
    96         sdescriptor[2] = descriptor->ports_count;
    97         /// @fixme handling of endianness??
    98         sdescriptor[3] = descriptor->hub_characteristics / 256;
    99         sdescriptor[4] = descriptor->hub_characteristics % 256;
    100         sdescriptor[5] = descriptor->pwr_on_2_good_time;
    101         sdescriptor[6] = descriptor->current_requirement;
    102 
    103         size_t i;
    104         for (i = 0; i < var_size; ++i) {
    105                 sdescriptor[7 + i] = descriptor->devices_removable[i];
    106         }
    107         for (i = 0; i < var_size; ++i) {
    108                 sdescriptor[7 + var_size + i] = 255;
    109         }
    110 }
    111 
    112 
    113 /**
    114  * create deserialized desriptor structure out of serialized descriptor
    115  *
    116  * The serialized descriptor must be proper usb hub descriptor,
    117  * otherwise an eerror might occur.
    118  *
    119  * @param sdescriptor serialized descriptor
    120  * @return newly created deserialized descriptor pointer
    121  */
    122 usb_hub_descriptor_t * usb_create_deserialized_hub_desriptor(
     86usb_hub_descriptor_t * usb_deserialize_hub_desriptor(
    12387void * serialized_descriptor) {
    12488        uint8_t * sdescriptor = serialized_descriptor;
    … …  
    13195
    13296        usb_hub_descriptor_t * result = malloc(sizeof(usb_hub_descriptor_t));
    133         if(result)
    134                 usb_deserialize_hub_desriptor(serialized_descriptor,result);
     97       
     98
     99        result->ports_count = sdescriptor[2];
     100        /// @fixme handling of endianness??
     101        result->hub_characteristics = sdescriptor[4] + 256 * sdescriptor[3];
     102        result->pwr_on_2_good_time = sdescriptor[5];
     103        result->current_requirement = sdescriptor[6];
     104        size_t var_size = (result->ports_count+7) / 8;
     105        result->devices_removable = (uint8_t*) malloc(var_size);
     106
     107        size_t i;
     108        for (i = 0; i < var_size; ++i) {
     109                result->devices_removable[i] = sdescriptor[7 + i];
     110        }
    135111        return result;
    136112}
    137113
    138 /**
    139  * deserialize descriptor into given pointer
    140  *
    141  * @param serialized_descriptor
    142  * @param descriptor
    143  * @return
    144  */
    145 void usb_deserialize_hub_desriptor(
    146 void * serialized_descriptor, usb_hub_descriptor_t * descriptor) {
    147         uint8_t * sdescriptor = serialized_descriptor;
    148         descriptor->ports_count = sdescriptor[2];
    149         /// @fixme handling of endianness??
    150         descriptor->hub_characteristics = sdescriptor[4] + 256 * sdescriptor[3];
    151         descriptor->pwr_on_2_good_time = sdescriptor[5];
    152         descriptor->current_requirement = sdescriptor[6];
    153         size_t var_size = (descriptor->ports_count+7) / 8;
    154         //descriptor->devices_removable = (uint8_t*) malloc(var_size);
    155114
    156         size_t i;
    157         for (i = 0; i < var_size; ++i) {
    158                 descriptor->devices_removable[i] = sdescriptor[7 + i];
    159         }
    160 }
    161115
    162116/**

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

    rff76509 r8fd4ba0  
    152152            maximum of 255 ports).
    153153     */
    154     uint8_t devices_removable[32];
     154    uint8_t * devices_removable;
    155155
    156156    /**
Note: See TracChangeset for help on using the changeset viewer.