Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 98d06b8 in mainline


Ignore:
Timestamp:
2010-12-10T15:11:24Z (11 years ago)
Author:
Matus Dekanek <smekideki@…>
Branches:
lfn, master
Children:
c01255c
Parents:
b5ec347
Message:

hub driver:
connect a new device
init a hub

Location:
uspace/drv
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/usbhub/port_status.h

    rb5ec347 r98d06b8  
    4343 *
    4444 */
    45 typedef uint8_t usb_port_status_t[4];
     45typedef uint32_t usb_port_status_t;
    4646
    4747/**
     
    103103}
    104104
     105/**
     106 * set the device request to be a port disable request
     107 * @param request
     108 * @param port
     109 */
     110static inline void usb_hub_set_disable_port_request(
     111usb_device_request_setup_packet_t * request, uint16_t port
     112){
     113        request->index = port;
     114        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
     115        request->request = USB_HUB_REQUEST_SET_FEATURE;
     116        request->value = USB_HUB_FEATURE_C_PORT_SUSPEND;
     117        request->length = 0;
     118}
     119
     120/**
     121 * disable specified port
     122 * @param port
     123 * @return
     124 */
     125static inline usb_device_request_setup_packet_t *
     126usb_hub_create_disable_port_request(uint16_t port){
     127        usb_device_request_setup_packet_t * result =
     128                usb_new(usb_device_request_setup_packet_t);
     129        usb_hub_set_disable_port_request(result,port);
     130        return result;
     131}
     132
     133/**
     134 * set the device request to be a port disable request
     135 * @param request
     136 * @param port
     137 */
     138static inline void usb_hub_set_reset_port_request(
     139usb_device_request_setup_packet_t * request, uint16_t port
     140){
     141        request->index = port;
     142        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
     143        request->request = USB_HUB_REQUEST_SET_FEATURE;
     144        request->value = USB_HUB_FEATURE_PORT_RESET;
     145        request->length = 0;
     146}
     147
     148/**
     149 * disable specified port
     150 * @param port
     151 * @return
     152 */
     153static inline usb_device_request_setup_packet_t *
     154usb_hub_create_reset_port_request(uint16_t port){
     155        usb_device_request_setup_packet_t * result =
     156                usb_new(usb_device_request_setup_packet_t);
     157        usb_hub_set_reset_port_request(result,port);
     158        return result;
     159}
     160
     161/**
     162 * set the device request to be a port disable request
     163 * @param request
     164 * @param port
     165 */
     166static inline void usb_hub_set_power_port_request(
     167usb_device_request_setup_packet_t * request, uint16_t port
     168){
     169        request->index = port;
     170        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
     171        request->request = USB_HUB_REQUEST_SET_FEATURE;
     172        request->value = USB_HUB_FEATURE_PORT_POWER;
     173        request->length = 0;
     174}
    105175
    106176/** get i`th bit of port status */
    107177static inline bool usb_port_get_bit(usb_port_status_t * status, int idx)
    108178{
    109         return (((*status)[idx/8])>>(idx%8))%2;
     179        return (((*status)>>(idx))%2);
    110180}
    111181
     
    114184        usb_port_status_t * status, int idx, bool value)
    115185{
    116         (*status)[idx/8] = value?
    117                                ((*status)[idx/8]|(1<<(idx%8))):
    118                                ((*status)[idx/8]&(~(1<<(idx%8))));
     186        (*status) = value?
     187                               ((*status)|(1<<(idx))):
     188                               ((*status)&(~(1<<(idx))));
    119189}
    120190
  • uspace/drv/usbhub/usbhub_private.h

    rb5ec347 r98d06b8  
    100100 * @brief create hub structure instance
    101101 *
     102 * Set the address and port count information most importantly.
     103 *
    102104 * @param device
     105 * @param hc host controller phone
    103106 * @return
    104107 */
    105 usb_hub_info_t * usb_create_hub_info(device_t * device);
     108usb_hub_info_t * usb_create_hub_info(device_t * device, int hc);
    106109
    107110/** list of hubs maanged by this driver */
     
    146149
    147150/**
    148  * set the device requsst to be a set address request
     151 * set the device request to be a set address request
    149152 * @param request
    150153 * @param addr
     
    154157){
    155158        request->index = 0;
    156         request->request_type = 0;/// \TODO this is not very nice sollution
     159        request->request_type = 0;/// \TODO this is not very nice sollution, we ned constant
    157160        request->request = USB_DEVREQ_SET_ADDRESS;
    158161        request->value = addr;
    159162        request->length = 0;
    160163}
     164
     165/**
     166 * set the device request to be a get hub descriptor request.
     167 * @warning the size is allways set to USB_HUB_MAX_DESCRIPTOR_SIZE
     168 * @param request
     169 * @param addr
     170 */
     171static inline void usb_hub_get_descriptor_request(
     172usb_device_request_setup_packet_t * request
     173){
     174        request->index = 0;
     175        request->request_type = USB_HUB_REQ_TYPE_GET_DESCRIPTOR;
     176        request->request = USB_HUB_REQUEST_GET_DESCRIPTOR;
     177        request->value = USB_DESCTYPE_HUB;
     178        request->length = USB_HUB_MAX_DESCRIPTOR_SIZE;
     179}
     180
    161181
    162182
  • uspace/drv/usbhub/utils.c

    rb5ec347 r98d06b8  
    5858
    5959//hub descriptor utils
     60
    6061void * usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor) {
    6162        //base size
     
    107108
    108109//control transactions
     110
    109111int usb_drv_sync_control_read(
    110     int phone, usb_target_t target,
    111     usb_device_request_setup_packet_t * request,
    112     void * rcvd_buffer, size_t rcvd_size, size_t * actual_size
    113 ){
     112                int phone, usb_target_t target,
     113                usb_device_request_setup_packet_t * request,
     114                void * rcvd_buffer, size_t rcvd_size, size_t * actual_size
     115                ) {
    114116        usb_handle_t handle;
    115117        int opResult;
    116118        //setup
    117119        opResult = usb_drv_async_control_read_setup(phone, target,
    118         request, sizeof(usb_device_request_setup_packet_t),
    119         &handle);
    120         if(opResult!=EOK){
     120                        request, sizeof (usb_device_request_setup_packet_t),
     121                        &handle);
     122        if (opResult != EOK) {
    121123                return opResult;
    122124        }
    123125        opResult = usb_drv_async_wait_for(handle);
    124         if(opResult!=EOK){
     126        if (opResult != EOK) {
    125127                return opResult;
    126128        }
    127129        //read
    128130        opResult = usb_drv_async_control_read_data(phone, target,
    129             rcvd_buffer, rcvd_size, actual_size,
    130             &handle);
    131         if(opResult!=EOK){
     131                        rcvd_buffer, rcvd_size, actual_size,
     132                        &handle);
     133        if (opResult != EOK) {
    132134                return opResult;
    133135        }
    134136        opResult = usb_drv_async_wait_for(handle);
    135         if(opResult!=EOK){
     137        if (opResult != EOK) {
    136138                return opResult;
    137139        }
    138140        //finalize
    139141        opResult = usb_drv_async_control_read_status(phone, target,
    140             &handle);
    141         if(opResult!=EOK){
     142                        &handle);
     143        if (opResult != EOK) {
    142144                return opResult;
    143145        }
    144146        opResult = usb_drv_async_wait_for(handle);
    145         if(opResult!=EOK){
     147        if (opResult != EOK) {
    146148                return opResult;
    147149        }
     
    149151}
    150152
    151 
    152153int usb_drv_sync_control_write(
    153     int phone, usb_target_t target,
    154     usb_device_request_setup_packet_t * request,
    155     void * sent_buffer, size_t sent_size
    156 ){
     154                int phone, usb_target_t target,
     155                usb_device_request_setup_packet_t * request,
     156                void * sent_buffer, size_t sent_size
     157                ) {
    157158        usb_handle_t handle;
    158159        int opResult;
    159160        //setup
    160161        opResult = usb_drv_async_control_write_setup(phone, target,
    161         request, sizeof(usb_device_request_setup_packet_t),
    162         &handle);
    163         if(opResult!=EOK){
     162                        request, sizeof (usb_device_request_setup_packet_t),
     163                        &handle);
     164        if (opResult != EOK) {
    164165                return opResult;
    165166        }
    166167        opResult = usb_drv_async_wait_for(handle);
    167         if(opResult!=EOK){
     168        if (opResult != EOK) {
    168169                return opResult;
    169170        }
    170171        //write
    171172        opResult = usb_drv_async_control_write_data(phone, target,
    172         sent_buffer, sent_size,
    173         &handle);
    174         if(opResult!=EOK){
     173                        sent_buffer, sent_size,
     174                        &handle);
     175        if (opResult != EOK) {
    175176                return opResult;
    176177        }
    177178        opResult = usb_drv_async_wait_for(handle);
    178         if(opResult!=EOK){
     179        if (opResult != EOK) {
    179180                return opResult;
    180181        }
    181182        //finalize
    182183        opResult = usb_drv_async_control_write_status(phone, target,
    183         &handle);
    184         if(opResult!=EOK){
     184                        &handle);
     185        if (opResult != EOK) {
    185186                return opResult;
    186187        }
    187188        opResult = usb_drv_async_wait_for(handle);
    188         if(opResult!=EOK){
     189        if (opResult != EOK) {
    189190                return opResult;
    190191        }
     
    194195//list implementation
    195196
    196 usb_general_list_t * usb_lst_create(void){
     197usb_general_list_t * usb_lst_create(void) {
    197198        usb_general_list_t* result = usb_new(usb_general_list_t);
    198199        usb_lst_init(result);
     
    200201}
    201202
    202 void usb_lst_init(usb_general_list_t * lst){
     203void usb_lst_init(usb_general_list_t * lst) {
    203204        lst->prev = lst;
    204205        lst->next = lst;
     
    206207}
    207208
    208 void usb_lst_prepend(usb_general_list_t* item, void* data){
     209void usb_lst_prepend(usb_general_list_t* item, void* data) {
    209210        usb_general_list_t* appended = usb_new(usb_general_list_t);
    210         appended->data=data;
    211         appended->next=item;
    212         appended->prev=item->prev;
     211        appended->data = data;
     212        appended->next = item;
     213        appended->prev = item->prev;
    213214        item->prev->next = appended;
    214215        item->prev = appended;
    215216}
    216217
    217 void usb_lst_append(usb_general_list_t* item, void* data){
    218         usb_general_list_t* appended =usb_new(usb_general_list_t);
    219         appended->data=data;
    220         appended->next=item->next;
    221         appended->prev=item;
     218void usb_lst_append(usb_general_list_t* item, void* data) {
     219        usb_general_list_t* appended = usb_new(usb_general_list_t);
     220        appended->data = data;
     221        appended->next = item->next;
     222        appended->prev = item;
    222223        item->next->prev = appended;
    223224        item->next = appended;
    224225}
    225226
    226 
    227 void usb_lst_remove(usb_general_list_t* item){
     227void usb_lst_remove(usb_general_list_t* item) {
    228228        item->next->prev = item->prev;
    229229        item->prev->next = item->next;
    230230}
    231231
    232 
     232static void usb_hub_test_port_status(void) {
     233        printf("[usb_hub] -------------port status test---------\n");
     234        usb_port_status_t status = 0;
     235
     236        //printf("original status %d (should be 0)\n",(uint32_t)status);
     237        usb_port_set_bit(&status, 1, 1);
     238        //printf("%d =?= 2\n",(uint32_t)status);
     239        if (status != 2) {
     240                printf("[usb_port_status] test failed: wrong set of bit 1\n");
     241                return;
     242        }
     243        usb_port_set_bit(&status, 3, 1);
     244        if (status != 10) {
     245                printf("[usb_port_status] test failed: wrong set of bit 3\n");
     246                return;
     247        }
     248
     249        usb_port_set_bit(&status, 15, 1);
     250        if (status != 10 + (1 << 15)) {
     251                printf("[usb_port_status] test failed: wrong set of bit 15\n");
     252                return;
     253        }
     254        usb_port_set_bit(&status, 1, 0);
     255        if (status != 8 + (1 << 15)) {
     256                printf("[usb_port_status] test failed: wrong unset of bit 1\n");
     257                return;
     258        }
     259        int i;
     260        for (i = 0; i < 32; ++i) {
     261                if (i == 3 || i == 15) {
     262                        if (!usb_port_get_bit(&status, i)) {
     263                                printf("[usb_port_status] test failed: wrong bit at %d\n", i);
     264                        }
     265                } else {
     266                        if (usb_port_get_bit(&status, i)) {
     267                                printf("[usb_port_status] test failed: wrong bit at %d\n", i);
     268                        }
     269                }
     270        }
     271
     272        printf("test ok\n");
     273
     274
     275        //printf("%d =?= 10\n",(uint32_t)status);
     276
     277        //printf("this should be 0: %d \n",usb_port_get_bit(&status,0));
     278        //printf("this should be 1: %d \n",usb_port_get_bit(&status,1));
     279        //printf("this should be 0: %d \n",usb_port_get_bit(&status,2));
     280        //printf("this should be 1: %d \n",usb_port_get_bit(&status,3));
     281        //printf("this should be 0: %d \n",usb_port_get_bit(&status,4));
     282
     283
     284
     285
     286}
    233287
    234288//*********************************************
    235289//
    236 //  hub driver code
     290//  hub driver code, initialization
    237291//
    238292//*********************************************
    239293
    240 usb_hub_info_t * usb_create_hub_info(device_t * device) {
     294usb_hub_info_t * usb_create_hub_info(device_t * device, int hc) {
    241295        usb_hub_info_t* result = usb_new(usb_hub_info_t);
    242296        //result->device = device;
    243297        result->port_count = -1;
    244298
    245         //get hc connection
    246         int hc = usb_drv_hc_connect(NULL, 0);
    247         printf("[usb_hub] phone to hc = %d\n",hc);
     299
     300        printf("[usb_hub] phone to hc = %d\n", hc);
    248301        if (hc < 0) {
    249302                return result;
    250303        }
    251304        //get some hub info
    252 
    253         usb_address_t addr = usb_drv_get_my_address(hc,device);
    254         printf("[usb_hub] addres of newly created hub = %d\n",addr);
     305        /// \TODO get correct params
     306        usb_address_t addr = usb_drv_get_my_address(hc, device);
     307        addr = 7;
     308        printf("[usb_hub] addres of newly created hub = %d\n", addr);
    255309        /*if(addr<0){
    256310                //return result;
    257311               
    258312        }*/
     313
    259314        result->device = usb_new(usb_hcd_attached_device_info_t);
    260         result->device->address=addr;
    261         //hub configuration?
     315        result->device->address = addr;
     316
     317        // get hub descriptor
     318        usb_target_t target;
     319        target.address = addr;
     320        target.endpoint = 0;
     321        usb_device_request_setup_packet_t request;
     322        usb_hub_get_descriptor_request(&request);
     323        void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE);
     324        usb_hub_descriptor_t * descriptor;
     325        size_t received_size;
     326        int opResult;
     327
     328        opResult = usb_drv_sync_control_read(
     329                        hc, target, &request, serialized_descriptor,
     330                        USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
     331        if (opResult != EOK) {
     332                printf("[usb_hub] failed when receiving hub descriptor \n");
     333        }
     334        descriptor = usb_deserialize_hub_desriptor(serialized_descriptor);
     335        result->port_count = descriptor->ports_count;
     336        free(serialized_descriptor);
     337        free(descriptor);
     338
     339        //finish
     340
    262341        printf("[usb_hub] hub info created\n");
    263342
    264        
    265        
    266343        return result;
    267344}
     
    283360
    284361        //create the hub structure
    285         usb_hub_info_t * hub_info = usb_create_hub_info(dev);
     362        //get hc connection
     363        /// \TODO correct params
     364        int hc = usb_drv_hc_connect(NULL, 0);
     365
     366        usb_hub_info_t * hub_info = usb_create_hub_info(dev, hc);
     367        int port;
     368        int opResult;
     369        usb_device_request_setup_packet_t request;
     370        usb_target_t target;
     371        target.address = hub_info->device->address;
     372        target.endpoint = 0;
     373        for (port = 0; port < hub_info->port_count; ++port) {
     374                usb_hub_set_power_port_request(&request, port);
     375                opResult = usb_drv_sync_control_write(hc, target, &request, NULL, 0);
     376                if (opResult != EOK) {
     377                        printf("[usb_hub]something went wrong when setting hub`s %dth port\n", port);
     378                }
     379        }
     380        //ports powered, hub seems to be enabled
     381
     382        ipc_hangup(hc);
     383
     384        //add the hub to list
    286385        usb_lst_append(&usb_hub_list, hub_info);
    287386        printf("[usb_hub] hub info added to list\n");
    288387        //(void)hub_info;
    289388        check_hub_changes();
     389
     390        /// \TODO start the check loop, if not already started...
     391
     392        //this is just a test for port status bitmap type
     393        usb_hub_test_port_status();
     394
    290395        printf("[usb_hub] hub dev added\n");
    291         //test port status type...
    292396
    293397        return EOK;
     
    295399}
    296400
    297 
    298 
     401//*********************************************
     402//
     403//  hub driver code, main loop
     404//
     405//*********************************************
     406
     407/**
     408 * reset the port with new device and reserve the default address
     409 * @param hc
     410 * @param port
     411 * @param target
     412 */
     413
     414static void usb_hub_init_add_device(int hc, uint16_t port, usb_target_t target) {
     415        usb_device_request_setup_packet_t request;
     416        int opResult;
     417        printf("[usb_hub] some connection changed\n");
     418        opResult = usb_drv_reserve_default_address(hc);
     419        if (opResult != EOK) {
     420                printf("[usb_hub] cannot assign default address, it is probably used\n");
     421        }
     422        //reset port
     423        usb_hub_set_reset_port_request(&request, port);
     424        opResult = usb_drv_sync_control_write(
     425                        hc, target,
     426                        &request,
     427                        NULL, 0
     428                        );
     429        if (opResult != EOK) {
     430                //continue;
     431                printf("[usb_hub] something went wrong when reseting a port\n");
     432        }
     433}
     434
     435/**
     436 * finalize adding new device after port reset
     437 * @param hc
     438 * @param port
     439 * @param target
     440 */
     441static void usb_hub_finalize_add_device(
     442                int hc, uint16_t port, usb_target_t target) {
     443
     444        usb_device_request_setup_packet_t request;
     445        int opResult;
     446        printf("[usb_hub] finalizing add device\n");
     447        usb_address_t new_device_address =
     448                        usb_drv_request_address(hc);
     449        usb_hub_set_set_address_request
     450                        (&request, new_device_address);
     451        opResult = usb_drv_sync_control_write(
     452                        hc, target,
     453                        &request,
     454                        NULL, 0
     455                        );
     456        if (opResult != EOK) {
     457                printf("[usb_hub] could not set address for new device\n");
     458        }
     459        usb_drv_release_default_address(hc);
     460
     461
     462        /// \TODO driver work
     463}
     464
     465/**
     466 * unregister device address in hc, close the port
     467 * @param hc
     468 * @param port
     469 * @param target
     470 */
     471static void usb_hub_removed_device(int hc, uint16_t port, usb_target_t target) {
     472        usb_device_request_setup_packet_t request;
     473        int opResult;
     474        //disable port
     475        usb_hub_set_disable_port_request(&request, port);
     476        opResult = usb_drv_sync_control_write(
     477                        hc, target,
     478                        &request,
     479                        NULL, 0
     480                        );
     481        if (opResult != EOK) {
     482                //continue;
     483                printf("[usb_hub] something went wrong when disabling a port\n");
     484        }
     485        //remove device
     486        //close address
     487        //
     488
     489        ///\TODO this code is not complete
     490}
     491
     492/**
     493 * process interrupts on given hub port
     494 * @param hc
     495 * @param port
     496 * @param target
     497 */
     498static void usb_hub_process_interrupt(int hc, uint16_t port, usb_target_t target) {
     499        printf("[usb_hub] interrupt at port %d\n", port);
     500        //determine type of change
     501        usb_port_status_t status;
     502        size_t rcvd_size;
     503        usb_device_request_setup_packet_t request;
     504        int opResult;
     505        usb_hub_set_port_status_request(&request, port);
     506
     507        opResult = usb_drv_sync_control_read(
     508                        hc, target,
     509                        &request,
     510                        &status, 4, &rcvd_size
     511                        );
     512        if (opResult != EOK) {
     513                printf("[usb_hub] ERROR: could not get port status\n");
     514                return;
     515        }
     516        if (rcvd_size != sizeof (usb_port_status_t)) {
     517                printf("[usb_hub] ERROR: received status has incorrect size\n");
     518                return;
     519        }
     520        //something connected/disconnected
     521        if (usb_port_connect_change(&status)) {
     522                if (usb_port_dev_connected(&status)) {
     523                        printf("[usb_hub] some connection changed\n");
     524                        usb_hub_init_add_device(hc, port, target);
     525                } else {
     526                        usb_hub_removed_device(hc, port, target);
     527                }
     528        }
     529        //port reset
     530        if (usb_port_reset_completed(&status)) {
     531                printf("[usb_hub] finalizing add device\n");
     532                if (usb_port_enabled(&status)) {
     533                        usb_hub_finalize_add_device(hc, port, target);
     534                } else {
     535                        printf("[usb_hub] ERROR: port reset, but port still not enabled\n");
     536                }
     537        }
     538
     539        usb_port_set_connect_change(&status, false);
     540        usb_port_set_reset(&status, false);
     541        usb_port_set_reset_completed(&status, false);
     542        usb_port_set_dev_connected(&status, false);
     543        if (status) {
     544                printf("[usb_hub]there was some unsupported change on port\n");
     545        }
     546        /// \TODO handle other changes
     547        /// \TODO debug log for various situations
     548
     549
     550
     551        /*
     552        //configure device
     553        usb_drv_reserve_default_address(hc);
     554
     555        usb_address_t new_device_address = usb_drv_request_address(hc);
     556
     557
     558        usb_drv_release_default_address(hc);
     559         * */
     560}
    299561
    300562/** Check changes on all known hubs.
     
    306568        usb_general_list_t * lst_item;
    307569        for (lst_item = usb_hub_list.next;
    308              lst_item != &usb_hub_list;
    309              lst_item = lst_item->next) {
     570                        lst_item != &usb_hub_list;
     571                        lst_item = lst_item->next) {
    310572                printf("[usb_hub] checking hub changes\n");
    311573                /*
    312574                 * Check status change pipe of this hub.
    313575                 */
    314                
     576
    315577                usb_target_t target = {
    316578                        .address = 5,
     
    327589                /// \FIXME this is incorrect code: here
    328590                /// must be used particular device instead of NULL
     591                //which one?
    329592                int hc = usb_drv_hc_connect(NULL, 0);
    330593                if (hc < 0) {
     
    348611                usb_drv_async_wait_for(handle);
    349612
    350                 if(opResult!=EOK){
     613                if (opResult != EOK) {
    351614                        printf("[usb_hub] something went wrong while getting status of hub\n");
    352615                        continue;
    353616                }
    354617                unsigned int port;
    355                 for(port=0;port<port_count;++port){
    356                         bool interrupt = (((uint8_t*)change_bitmap)[port/8]>>(port%8))%2;
    357                         if(interrupt){
    358                                 printf("[usb_hub] interrupt at port %d\n",port);
    359                                 //determine type of change
    360                                 usb_port_status_t status;
    361                                 size_t rcvd_size;
    362                                 usb_device_request_setup_packet_t request;
    363                                 usb_hub_set_port_status_request(&request,port);
    364 
    365                                 opResult = usb_drv_sync_control_read(
    366                                     hc, target,
    367                                     &request,
    368                                     &status, 4, &rcvd_size
    369                                 );
    370                                 if(opResult!=EOK){
    371                                         continue;
    372                                 }
    373                                 if(rcvd_size!=sizeof(usb_port_status_t)){
    374                                         continue;
    375                                 }
    376                                
    377                                 if(usb_port_connect_change(&status)){
    378                                         printf("[usb_hub] some connectionchanged\n");
    379                                         usb_drv_reserve_default_address(hc);
    380                                         //enable port
    381                                         usb_hub_set_enable_port_request(&request,port);
    382                                         opResult = usb_drv_sync_control_write(
    383                                                 hc, target,
    384                                                 &request,
    385                                                 NULL, 0
    386                                         );
    387                                         if(opResult!=EOK){
    388                                                 continue;
    389                                         }
    390                                         //set address
    391                                         usb_address_t new_device_address =
    392                                                         usb_drv_request_address(hc);
    393                                         usb_hub_set_set_address_request
    394                                                         (&request,new_device_address);
    395                                         opResult = usb_drv_sync_control_write(
    396                                                 hc, target,
    397                                                 &request,
    398                                                 NULL, 0
    399                                         );
    400                                         //some other work with drivers
    401                                         /// \TODO do the work with drivers
    402 
    403 
    404                                         usb_drv_release_default_address(hc);
    405                                 }else{
    406                                         printf("[usb_hub] no supported event occured\n");
    407                                 }
    408                                 /// \TODO handle other changes
    409                                 /// \TODO debug log for various situations
    410 
    411 
    412 
    413                                 /*
    414                                 //configure device
    415                                 usb_drv_reserve_default_address(hc);
    416 
    417                                 usb_address_t new_device_address = usb_drv_request_address(hc);
    418 
    419 
    420                                 usb_drv_release_default_address(hc);
    421                                  * */
     618                for (port = 0; port < port_count; ++port) {
     619                        bool interrupt = (((uint8_t*) change_bitmap)[port / 8] >> (port % 8)) % 2;
     620                        if (interrupt) {
     621                                usb_hub_process_interrupt(hc, port, target);
    422622                        }
    423623                }
  • uspace/drv/vhc/hub.c

    rb5ec347 r98d06b8  
    161161       
    162162        usbvirt_connect_local(&virthub_dev);
     163
     164        virthub_dev.address = 7;
    163165       
    164166        dprintf(1, "virtual hub (%d ports) created", HUB_PORT_COUNT);
Note: See TracChangeset for help on using the changeset viewer.