Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/root_hub.c

    r8b74997f rccbcd895  
    4747 *      standart device descriptor for ohci root hub
    4848 */
    49 static 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,
     49static 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,
    6465};
    6566
    … …  
    6869 * for ohci root hubs
    6970 */
    70 static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor = {
     71static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor =
     72{
    7173        /// \TODO some values are default or guessed
    72         .attributes = 1 << 7,
     74        .attributes = 1<<7,
    7375        .configuration_number = 1,
    7476        .descriptor_type = USB_DESCTYPE_CONFIGURATION,
    7577        .interface_count = 1,
    76         .length = sizeof (usb_standard_configuration_descriptor_t),
     78        .length = sizeof(usb_standard_configuration_descriptor_t),
    7779        .max_power = 100,
    7880        .str_configuration = 0,
    … …  
    8284 * standart ohci root hub interface descriptor
    8385 */
    84 static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor = {
     86static const usb_standard_interface_descriptor_t ohci_rh_iface_descriptor =
     87{
    8588        .alternate_setting = 0,
    8689        .descriptor_type = USB_DESCTYPE_INTERFACE,
    … …  
    9194        .interface_protocol = 0,
    9295        .interface_subclass = 0,
    93         .length = sizeof (usb_standard_interface_descriptor_t),
     96        .length = sizeof(usb_standard_interface_descriptor_t),
    9497        .str_interface = 0,
    9598};
    … …  
    98101 * standart ohci root hub endpoint descriptor
    99102 */
    100 static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor = {
     103static const usb_standard_endpoint_descriptor_t ohci_rh_ep_descriptor =
     104{
    101105        .attributes = USB_TRANSFER_INTERRUPT,
    102106        .descriptor_type = USB_DESCTYPE_ENDPOINT,
    103         .endpoint_address = 1 + (1 << 7),
    104         .length = sizeof (usb_standard_endpoint_descriptor_t),
     107        .endpoint_address = 1 + (1<<7),
     108        .length = sizeof(usb_standard_endpoint_descriptor_t),
    105109        .max_packet_size = 8,
    106110        .poll_interval = 255,
    … …  
    108112
    109113static const uint32_t hub_clear_feature_valid_mask =
    110         (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) |
    111 (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
     114        (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) +
     115        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
    112116
    113117static const uint32_t hub_clear_feature_by_writing_one_mask =
    … …  
    117121        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
    118122
    119 
     123       
    120124static const uint32_t hub_set_feature_direct_mask =
    121125        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
    122126
    123127static const uint32_t port_set_feature_valid_mask =
    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);
     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);
    128132
    129133static const uint32_t port_clear_feature_valid_mask =
    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 
    142 static 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 
    150 static void usb_create_serialized_hub_descriptor(rh_t *instance,
    151         uint8_t ** out_result,
    152         size_t * out_size);
    153 
    154 static void rh_init_descriptors(rh_t *instance);
    155 
    156 static int process_get_port_status_request(rh_t *instance, uint16_t port,
    157         usb_transfer_batch_t * request);
    158 
    159 static int process_get_hub_status_request(rh_t *instance,
    160         usb_transfer_batch_t * request);
    161 
    162 static int process_get_status_request(rh_t *instance,
    163         usb_transfer_batch_t * request);
    164 
    165 static void create_interrupt_mask(rh_t *instance, void ** buffer,
    166         size_t * buffer_size);
    167 
    168 static int process_get_descriptor_request(rh_t *instance,
    169         usb_transfer_batch_t *request);
    170 
    171 static int process_get_configuration_request(rh_t *instance,
    172         usb_transfer_batch_t *request);
    173 
    174 static int process_hub_feature_set_request(rh_t *instance, uint16_t feature);
    175 
    176 static int process_hub_feature_clear_request(rh_t *instance,
    177         uint16_t feature);
    178 
    179 static int process_port_feature_set_request(rh_t *instance,
    180         uint16_t feature, uint16_t port);
    181 
    182 static int process_port_feature_clear_request(rh_t *instance,
    183         uint16_t feature, uint16_t port);
    184 
    185 static int process_address_set_request(rh_t *instance,
    186         uint16_t address);
    187 
    188 static int process_request_with_output(rh_t *instance,
    189         usb_transfer_batch_t *request);
    190 
    191 static int process_request_with_input(rh_t *instance,
    192         usb_transfer_batch_t *request);
    193 
    194 static int process_request_without_data(rh_t *instance,
    195         usb_transfer_batch_t *request);
    196 
    197 static 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  */
    206 int 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  */
    233 int 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(request, opResult);
    252         return EOK;
    253 }
    254 
    255 /*----------------------------------------------------------------------------*/
    256 
    257 
    258 void 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 /*----------------------------------------------------------------------------*/
     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
    264147
    265148/**
    … …  
    274157 */
    275158static void usb_create_serialized_hub_descriptor(rh_t *instance,
    276         uint8_t ** out_result,
    277         size_t * out_size) {
     159                uint8_t ** out_result,
     160                size_t * out_size) {
    278161        //base size
    279162        size_t size = 7;
    280163        //variable size according to port count
    281164        size_t var_size = instance->port_count / 8 +
    282                 ((instance->port_count % 8 > 0) ? 1 : 0);
     165                        ((instance->port_count % 8 > 0) ? 1 : 0);
    283166        size += 2 * var_size;
    284167        uint8_t * result = (uint8_t*) malloc(size);
    285         bzero(result, size);
     168        bzero(result,size);
    286169        //size
    287170        result[0] = size;
    … …  
    291174        uint32_t hub_desc_reg = instance->registers->rh_desc_a;
    292175        result[3] =
    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);
     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);
    298181        result[4] = 0;
    299182        result[5] = /*descriptor->pwr_on_2_good_time*/ 50;
    … …  
    302185        int port;
    303186        for (port = 1; port <= instance->port_count; ++port) {
    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);
     187                result[7 + port/8] +=
     188                                ((instance->registers->rh_desc_b >> port)%2) << (port%8);
    308189        }
    309190        size_t i;
    … …  
    314195        (*out_size) = size;
    315196}
    316 /*----------------------------------------------------------------------------*/
     197
    317198
    318199/** initialize hub descriptors
    … …  
    322203 * @instance root hub instance
    323204 */
    324 static void rh_init_descriptors(rh_t *instance) {
     205static void rh_init_descriptors(rh_t *instance){
    325206        memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor,
    326                 sizeof (ohci_rh_device_descriptor)
    327                 );
     207                sizeof(ohci_rh_device_descriptor)
     208        );
    328209        usb_standard_configuration_descriptor_t descriptor;
    329         memcpy(&descriptor, &ohci_rh_conf_descriptor,
    330                 sizeof (ohci_rh_conf_descriptor));
     210        memcpy(&descriptor,&ohci_rh_conf_descriptor,
     211                        sizeof(ohci_rh_conf_descriptor));
    331212        uint8_t * hub_descriptor;
    332213        size_t hub_desc_size;
    333214        usb_create_serialized_hub_descriptor(instance, &hub_descriptor,
    334                 &hub_desc_size);
     215                        &hub_desc_size);
    335216
    336217        descriptor.total_length =
    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 
     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       
    342223        uint8_t * full_config_descriptor =
    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 
     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       
    355236        instance->descriptors.configuration = full_config_descriptor;
    356237        instance->descriptors.configuration_size = descriptor.total_length;
    357238}
     239
     240/** Root hub initialization
     241 * @return Error code.
     242 */
     243int 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}
    358261/*----------------------------------------------------------------------------*/
    359262
    … …  
    369272 */
    370273static int process_get_port_status_request(rh_t *instance, uint16_t port,
    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;
     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;
    375278        request->transfered_size = 4;
    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 /*----------------------------------------------------------------------------*/
     279        uint32_buffer[0] = instance->registers->rh_port_status[port -1];
     280        return EOK;
     281}
    388282
    389283/**
    … …  
    397291 */
    398292static int process_get_hub_status_request(rh_t *instance,
    399         usb_transfer_batch_t * request) {
    400         uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
     293                usb_transfer_batch_t * request){
     294        uint32_t * uint32_buffer = (uint32_t*)request->transport_buffer;
     295        //bits, 0,1,16,17
    401296        request->transfered_size = 4;
    402         //bits, 0,1,16,17
    403         uint32_t mask = 1 | (1 << 1) | (1 << 16) | (1 << 17);
     297        uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17);
    404298        uint32_buffer[0] = mask & instance->registers->rh_status;
    405299        return EOK;
    406 }
    407 /*----------------------------------------------------------------------------*/
     300
     301}
     302
     303
    408304
    409305/**
    … …  
    417313 */
    418314static int process_get_status_request(rh_t *instance,
    419         usb_transfer_batch_t * request) {
     315                usb_transfer_batch_t * request)
     316{
    420317        size_t buffer_size = request->buffer_size;
    421318        usb_device_request_setup_packet_t * request_packet =
    422                 (usb_device_request_setup_packet_t*)
    423                 request->setup_buffer;
     319                        (usb_device_request_setup_packet_t*)
     320                        request->setup_buffer;
    424321
    425322        usb_hub_bm_request_type_t request_type = request_packet->request_type;
    426         if (buffer_size < 4/*request_packet->length*/) {///\TODO
     323        if(buffer_size<4/*request_packet->length*/){///\TODO
    427324                usb_log_warning("requested more data than buffer size\n");
    428325                return EINVAL;
    429326        }
    430327
    431         if (request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
     328        if(request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
    432329                return process_get_hub_status_request(instance, 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);
     330        if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
     331                return process_get_port_status_request(instance, request_packet->index,
     332                                request);
    437333        return ENOTSUP;
    438334}
    439 /*----------------------------------------------------------------------------*/
    440335
    441336/**
    … …  
    444339 * Result contains bitmap where bit 0 indicates change on hub and
    445340 * bit i indicates change on i`th port (i>0). For more info see
    446  * Hub and Port status bitmap specification in USB specification
    447  * (chapter 11.13.4)
     341 * Hub and Port status bitmap specification in USB specification.
    448342 * @param instance root hub instance
    449343 * @param@out buffer pointer to created interrupt mas
    … …  
    451345 */
    452346static void create_interrupt_mask(rh_t *instance, void ** buffer,
    453         size_t * buffer_size) {
     347                size_t * buffer_size){
    454348        int bit_count = instance->port_count + 1;
    455         (*buffer_size) = (bit_count / 8) + ((bit_count % 8 == 0) ? 0 : 1);
    456 
     349        (*buffer_size) = (bit_count / 8) + (bit_count%8==0)?0:1;
    457350        (*buffer) = malloc(*buffer_size);
    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) {
     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){
    463355                bitmap[0] = 1;
    464356        }
    465357        int port;
    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 
     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 
    475369/**
    476370 * create answer to a descriptor request
    … …  
    483377 */
    484378static int process_get_descriptor_request(rh_t *instance,
    485         usb_transfer_batch_t *request) {
     379                usb_transfer_batch_t *request){
    486380        usb_device_request_setup_packet_t * setup_request =
    487                 (usb_device_request_setup_packet_t*) request->setup_buffer;
     381                        (usb_device_request_setup_packet_t*)request->setup_buffer;
    488382        size_t size;
    489383        const void * result_descriptor = NULL;
    490384        const uint16_t setup_request_value = setup_request->value_high;
    491         //(setup_request->value_low << 8);
     385                        //(setup_request->value_low << 8);
    492386        bool del = false;
    493         switch (setup_request_value) {
    494                 case USB_DESCTYPE_HUB:
    495                 {
     387        switch (setup_request_value)
     388        {
     389                case USB_DESCTYPE_HUB: {
    496390                        uint8_t * descriptor;
    497391                        usb_create_serialized_hub_descriptor(
    498392                                instance, &descriptor, &size);
    499393                        result_descriptor = descriptor;
    500                         if (result_descriptor) del = true;
     394                        if(result_descriptor) del = true;
    501395                        break;
    502396                }
    503                 case USB_DESCTYPE_DEVICE:
    504                 {
     397                case USB_DESCTYPE_DEVICE: {
    505398                        usb_log_debug("USB_DESCTYPE_DEVICE\n");
    506399                        result_descriptor = &ohci_rh_device_descriptor;
    507                         size = sizeof (ohci_rh_device_descriptor);
     400                        size = sizeof(ohci_rh_device_descriptor);
    508401                        break;
    509402                }
    510                 case USB_DESCTYPE_CONFIGURATION:
    511                 {
     403                case USB_DESCTYPE_CONFIGURATION: {
    512404                        usb_log_debug("USB_DESCTYPE_CONFIGURATION\n");
    513405                        result_descriptor = instance->descriptors.configuration;
    … …  
    515407                        break;
    516408                }
    517                 case USB_DESCTYPE_INTERFACE:
    518                 {
     409                case USB_DESCTYPE_INTERFACE: {
    519410                        usb_log_debug("USB_DESCTYPE_INTERFACE\n");
    520411                        result_descriptor = &ohci_rh_iface_descriptor;
    521                         size = sizeof (ohci_rh_iface_descriptor);
     412                        size = sizeof(ohci_rh_iface_descriptor);
    522413                        break;
    523414                }
    524                 case USB_DESCTYPE_ENDPOINT:
    525                 {
     415                case USB_DESCTYPE_ENDPOINT: {
    526416                        usb_log_debug("USB_DESCTYPE_ENDPOINT\n");
    527417                        result_descriptor = &ohci_rh_ep_descriptor;
    528                         size = sizeof (ohci_rh_ep_descriptor);
     418                        size = sizeof(ohci_rh_ep_descriptor);
    529419                        break;
    530420                }
    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                                 );
     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                                        );
    543430                        return EINVAL;
    544431                }
    545432        }
    546         if (request->buffer_size < size) {
     433        if(request->buffer_size < size){
    547434                size = request->buffer_size;
    548435        }
    549436        request->transfered_size = size;
    550         memcpy(request->transport_buffer, result_descriptor, 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));
    551440        if (del)
    552441                free(result_descriptor);
    553442        return EOK;
    554443}
    555 /*----------------------------------------------------------------------------*/
    556444
    557445/**
    … …  
    563451 * @return error code
    564452 */
    565 static int process_get_configuration_request(rh_t *instance,
    566         usb_transfer_batch_t *request) {
     453static int process_get_configuration_request(rh_t *instance, 
     454                usb_transfer_batch_t *request){
    567455        //set and get configuration requests do not have any meaning, only dummy
    568456        //values are returned
    569         if (request->buffer_size != 1)
     457        if(request->buffer_size != 1)
    570458                return EINVAL;
    571459        request->transport_buffer[0] = 1;
    … …  
    573461        return EOK;
    574462}
    575 /*----------------------------------------------------------------------------*/
    576463
    577464/**
    578465 * process feature-enabling request on hub
    579  *
     466 * 
    580467 * @param instance root hub instance
    581468 * @param feature feature selector
    … …  
    583470 */
    584471static int process_hub_feature_set_request(rh_t *instance,
    585         uint16_t feature) {
    586         if (!((1 << feature) & hub_set_feature_valid_mask))
     472                uint16_t feature){
     473        if(! ((1<<feature) & hub_set_feature_valid_mask))
    587474                return EINVAL;
    588475        instance->registers->rh_status =
    589                 (instance->registers->rh_status | (1 << feature))
    590                 & (~hub_clear_feature_by_writing_one_mask);
    591         return EOK;
    592 }
    593 /*----------------------------------------------------------------------------*/
     476                        (instance->registers->rh_status | (1<<feature))
     477                        & (~ hub_clear_feature_by_writing_one_mask);
     478        return EOK;
     479}
    594480
    595481/**
    … …  
    601487 */
    602488static int process_hub_feature_clear_request(rh_t *instance,
    603         uint16_t feature) {
    604         if (!((1 << feature) & hub_clear_feature_valid_mask))
     489                uint16_t feature){
     490        if(! ((1<<feature) & hub_clear_feature_valid_mask))
    605491                return EINVAL;
    606492        //is the feature cleared directly?
    607         if ((1 << feature) & hub_set_feature_direct_mask) {
     493        if ((1<<feature) & hub_set_feature_direct_mask){
    608494                instance->registers->rh_status =
    609                         (instance->registers->rh_status & (~(1 << feature)))
    610                         & (~hub_clear_feature_by_writing_one_mask);
    611         } else {//the feature is cleared by writing '1'
     495                        (instance->registers->rh_status & (~(1<<feature)))
     496                        & (~ hub_clear_feature_by_writing_one_mask);
     497        }else{//the feature is cleared by writing '1'
    612498                instance->registers->rh_status =
    613                         (instance->registers->rh_status
    614                         & (~hub_clear_feature_by_writing_one_mask))
    615                         | (1 << feature);
    616         }
    617         return EOK;
    618 }
    619 /*----------------------------------------------------------------------------*/
     499                                (instance->registers->rh_status
     500                                & (~ hub_clear_feature_by_writing_one_mask))
     501                                | (1<<feature);
     502        }
     503        return EOK;
     504}
     505
     506
    620507
    621508/**
    622509 * process feature-enabling request on hub
    623  *
     510 * 
    624511 * @param instance root hub instance
    625512 * @param feature feature selector
    … …  
    629516 */
    630517static int process_port_feature_set_request(rh_t *instance,
    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)
     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)
    635522                return EINVAL;
    636523        instance->registers->rh_port_status[port - 1] =
    637                 (instance->registers->rh_port_status[port - 1] | (1 << feature))
    638                 & (~port_clear_feature_valid_mask);
     524                        (instance->registers->rh_port_status[port - 1] | (1<<feature))
     525                        & (~port_clear_feature_valid_mask);
    639526        /// \TODO any error?
    640527        return EOK;
    641528}
    642 /*----------------------------------------------------------------------------*/
    643529
    644530/**
    … …  
    652538 */
    653539static int process_port_feature_clear_request(rh_t *instance,
    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)
     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)
    660546                feature = USB_HUB_FEATURE_PORT_LOW_SPEED;
    661         if (feature == USB_HUB_FEATURE_PORT_SUSPEND)
     547        if(feature == USB_HUB_FEATURE_PORT_SUSPEND)
    662548                feature = USB_HUB_FEATURE_PORT_OVER_CURRENT;
    663549        instance->registers->rh_port_status[port - 1] =
    664                 (instance->registers->rh_port_status[port - 1]
    665                 & (~port_clear_feature_valid_mask))
    666                 | (1 << feature);
     550                        (instance->registers->rh_port_status[port - 1]
     551                        & (~port_clear_feature_valid_mask))
     552                        | (1<<feature);
    667553        /// \TODO any error?
    668554        return EOK;
    669555}
    670 /*----------------------------------------------------------------------------*/
     556
    671557
    672558/**
    673559 * register address to this device
    674  *
     560 * 
    675561 * @param instance root hub instance
    676562 * @param address new address
    … …  
    678564 */
    679565static int process_address_set_request(rh_t *instance,
    680         uint16_t address) {
     566                uint16_t address){
    681567        instance->address = address;
    682568        return EOK;
    683569}
    684 /*----------------------------------------------------------------------------*/
    685570
    686571/**
    … …  
    694579 */
    695580static int process_request_with_output(rh_t *instance,
    696         usb_transfer_batch_t *request) {
     581                usb_transfer_batch_t *request){
    697582        usb_device_request_setup_packet_t * setup_request =
    698                 (usb_device_request_setup_packet_t*) request->setup_buffer;
    699         if (setup_request->request == USB_DEVREQ_GET_STATUS) {
     583                        (usb_device_request_setup_packet_t*)request->setup_buffer;
     584        if(setup_request->request == USB_DEVREQ_GET_STATUS){
    700585                usb_log_debug("USB_DEVREQ_GET_STATUS\n");
    701586                return process_get_status_request(instance, request);
    702587        }
    703         if (setup_request->request == USB_DEVREQ_GET_DESCRIPTOR) {
     588        if(setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){
    704589                usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n");
    705590                return process_get_descriptor_request(instance, request);
    706591        }
    707         if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION) {
     592        if(setup_request->request == USB_DEVREQ_GET_CONFIGURATION){
    708593                usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
    709594                return process_get_configuration_request(instance, request);
    … …  
    711596        return ENOTSUP;
    712597}
    713 /*----------------------------------------------------------------------------*/
    714598
    715599/**
    … …  
    723607 */
    724608static int process_request_with_input(rh_t *instance,
    725         usb_transfer_batch_t *request) {
     609                usb_transfer_batch_t *request){
    726610        usb_device_request_setup_packet_t * setup_request =
    727                 (usb_device_request_setup_packet_t*) request->setup_buffer;
     611                        (usb_device_request_setup_packet_t*)request->setup_buffer;
    728612        request->transfered_size = 0;
    729         if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR) {
     613        if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){
    730614                return ENOTSUP;
    731615        }
    732         if (setup_request->request == USB_DEVREQ_SET_CONFIGURATION) {
     616        if(setup_request->request == USB_DEVREQ_SET_CONFIGURATION){
    733617                //set and get configuration requests do not have any meaning,
    734618                //only dummy values are returned
    … …  
    737621        return ENOTSUP;
    738622}
    739 /*----------------------------------------------------------------------------*/
    740623
    741624/**
    … …  
    749632 */
    750633static int process_request_without_data(rh_t *instance,
    751         usb_transfer_batch_t *request) {
     634                usb_transfer_batch_t *request){
    752635        usb_device_request_setup_packet_t * setup_request =
    753                 (usb_device_request_setup_packet_t*) request->setup_buffer;
     636                        (usb_device_request_setup_packet_t*)request->setup_buffer;
    754637        request->transfered_size = 0;
    755         if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE) {
    756                 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE) {
     638        if(setup_request->request == USB_DEVREQ_CLEAR_FEATURE){
     639                if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){
    757640                        usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
    758641                        return process_hub_feature_clear_request(instance,
    759                                 setup_request->value);
    760                 }
    761                 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
     642                                        setup_request->value);
     643                }
     644                if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
    762645                        usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
    763646                        return process_port_feature_clear_request(instance,
    764                                 setup_request->value,
    765                                 setup_request->index);
     647                                        setup_request->value,
     648                                        setup_request->index);
    766649                }
    767650                usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
    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) {
     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){
    773656                        usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
    774657                        return process_hub_feature_set_request(instance,
    775                                 setup_request->value);
    776                 }
    777                 if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
     658                                        setup_request->value);
     659                }
     660                if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
    778661                        usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
    779662                        return process_port_feature_set_request(instance,
    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) {
     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){
    788670                usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
    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);
     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);
    794674        return ENOTSUP;
    795675}
    796 /*----------------------------------------------------------------------------*/
    797676
    798677/**
    … …  
    814693 * @return error code
    815694 */
    816 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request) {
    817         if (!request->setup_buffer) {
     695static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request){
     696        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                ){
     711                        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                                        );
     729                        opResult = ENOTSUP;
     730                }
     731        }else{
    818732                usb_log_error("root hub received empty transaction?");
    819                 return EINVAL;
    820         }
     733                opResult = EINVAL;
     734        }
     735        return opResult;
     736}
     737
     738/**
     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 */
     745int rh_request(rh_t *instance, usb_transfer_batch_t *request)
     746{
     747        assert(instance);
     748        assert(request);
    821749        int opResult;
    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:
    836                         usb_log_debug("processing request with output\n");
    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                                 );
    860                         opResult = ENOTSUP;
    861         }
    862         return opResult;
    863 }
    864 
    865 
    866 
    867 
     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
     769void 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}
    868774/**
    869775 * @}
Note: See TracChangeset for help on using the changeset viewer.