Changes in / [8dd039a:557c7d0] in mainline


Ignore:
Location:
uspace
Files:
3 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/usbhub/Makefile

    r8dd039a r557c7d0  
    3434SOURCES = \
    3535        main.c \
    36         utils.c \
    37         usbhub.c \
    38         usblist.c
     36        utils.c
    3937
    4038include $(USPACE_PREFIX)/Makefile.common
  • uspace/drv/usbhub/main.c

    r8dd039a r557c7d0  
    3232
    3333#include <usb/usbdrv.h>
    34 
    3534#include "usbhub.h"
    3635#include "usbhub_private.h"
     
    5958int main(int argc, char *argv[])
    6059{
    61         usb_dprintf_enable(NAME,1);
    6260        usb_lst_init(&usb_hub_list);
    6361        fid_t fid = fibril_create(usb_hub_control_loop, NULL);
    6462        if (fid == 0) {
    65                 dprintf(1, "failed to start fibril for HUB devices");
    66                 //printf("%s: failed to start fibril for HUB devices\n", NAME);
     63                printf("%s: failed to start fibril for HUB devices\n", NAME);
    6764                return ENOMEM;
    6865        }
  • uspace/drv/usbhub/usbhub_private.h

    r8dd039a r557c7d0  
    3838
    3939#include "usbhub.h"
    40 #include "usblist.h"
    41 
    4240#include <adt/list.h>
    4341#include <bool.h>
    4442#include <driver.h>
    4543#include <usb/usb.h>
    46 #include <usb/usbdrv.h>
    4744#include <usb/classes/hub.h>
    4845#include <usb/devreq.h>
    49 #include <usb/debug.h>
    5046
    5147//************
     
    5955//************
    6056//
    61 // convenience debug printf
    62 //
    63 //************
    64 #define dprintf(level, format, ...) \
    65         usb_dprintf(NAME, (level), format "\n", ##__VA_ARGS__)
     57// My private list implementation; I did not like the original helenos list
     58//
     59// This one does not depend on the structure of stored data
     60//
     61//************
     62
     63/** general list structure */
     64
     65
     66typedef struct usb_general_list{
     67        void * data;
     68        struct usb_general_list * prev, * next;
     69} usb_general_list_t;
     70
     71/** create head of usb general list */
     72usb_general_list_t * usb_lst_create(void);
     73
     74/** initialize head of usb general list */
     75void usb_lst_init(usb_general_list_t * lst);
     76
     77
     78/** is the list empty? */
     79static inline bool usb_lst_empty(usb_general_list_t * lst){
     80        return lst?(lst->next==lst):true;
     81}
     82
     83/** append data behind item */
     84void usb_lst_append(usb_general_list_t * lst, void * data);
     85
     86/** prepend data beore item */
     87void usb_lst_prepend(usb_general_list_t * lst, void * data);
     88
     89/** remove list item from list */
     90void usb_lst_remove(usb_general_list_t * item);
     91
     92/** get data o specified type from list item */
     93#define usb_lst_get_data(item, type)  (type *) (item->data)
     94
     95/** get usb_hub_info_t data from list item */
     96static inline usb_hub_info_t * usb_hub_lst_get_data(usb_general_list_t * item) {
     97        return usb_lst_get_data(item,usb_hub_info_t);
     98}
    6699
    67100/**
  • uspace/drv/usbhub/utils.c

    r8dd039a r557c7d0  
    3131 */
    3232/** @file
    33  * @brief various utilities
     33 * @brief Hub driver.
    3434 */
    3535#include <driver.h>
     
    9090
    9191        if (sdescriptor[1] != USB_DESCTYPE_HUB) {
    92                 dprintf(1,"[usb_hub] wrong descriptor %x\n",sdescriptor[1]);
     92                printf("[usb_hub] wrong descriptor %x\n",sdescriptor[1]);
    9393                return NULL;
    9494        }
     
    102102        result->pwr_on_2_good_time = sdescriptor[5];
    103103        result->current_requirement = sdescriptor[6];
    104         size_t var_size = result->ports_count / 8 + ((result->ports_count % 8 > 0)
    105                         ? 1 : 0);
     104        size_t var_size = result->ports_count / 8 + ((result->ports_count % 8 > 0) ? 1 : 0);
    106105        result->devices_removable = (uint8_t*) malloc(var_size);
    107106        //printf("[usb_hub] getting removable devices data \n");
     
    199198}
    200199
    201 
    202 /*
    203  * method for testing port status bitmap
    204  
     200//list implementation
     201
     202usb_general_list_t * usb_lst_create(void) {
     203        usb_general_list_t* result = usb_new(usb_general_list_t);
     204        usb_lst_init(result);
     205        return result;
     206}
     207
     208void usb_lst_init(usb_general_list_t * lst) {
     209        lst->prev = lst;
     210        lst->next = lst;
     211        lst->data = NULL;
     212}
     213
     214void usb_lst_prepend(usb_general_list_t* item, void* data) {
     215        usb_general_list_t* appended = usb_new(usb_general_list_t);
     216        appended->data = data;
     217        appended->next = item;
     218        appended->prev = item->prev;
     219        item->prev->next = appended;
     220        item->prev = appended;
     221}
     222
     223void usb_lst_append(usb_general_list_t* item, void* data) {
     224        usb_general_list_t* appended = usb_new(usb_general_list_t);
     225        appended->data = data;
     226        appended->next = item->next;
     227        appended->prev = item;
     228        item->next->prev = appended;
     229        item->next = appended;
     230}
     231
     232void usb_lst_remove(usb_general_list_t* item) {
     233        item->next->prev = item->prev;
     234        item->prev->next = item->next;
     235}
     236
    205237static void usb_hub_test_port_status(void) {
    206238        printf("[usb_hub] -------------port status test---------\n");
     
    254286        //printf("this should be 0: %d \n",usb_port_get_bit(&status,4));
    255287
    256 }
    257 */
    258 
     288
     289
     290
     291}
     292
     293//*********************************************
     294//
     295//  hub driver code, initialization
     296//
     297//*********************************************
     298
     299usb_hub_info_t * usb_create_hub_info(device_t * device, int hc) {
     300        usb_hub_info_t* result = usb_new(usb_hub_info_t);
     301        //result->device = device;
     302        result->port_count = -1;
     303        /// \TODO is this correct? is the device stored?
     304        result->device = device;
     305
     306
     307        //printf("[usb_hub] phone to hc = %d\n", hc);
     308        if (hc < 0) {
     309                return result;
     310        }
     311        //get some hub info
     312        usb_address_t addr = usb_drv_get_my_address(hc, device);
     313        printf("[usb_hub] addres of newly created hub = %d\n", addr);
     314        /*if(addr<0){
     315                //return result;
     316               
     317        }*/
     318
     319        result->usb_device = usb_new(usb_hcd_attached_device_info_t);
     320        result->usb_device->address = addr;
     321
     322        // get hub descriptor
     323        usb_target_t target;
     324        target.address = addr;
     325        target.endpoint = 0;
     326        usb_device_request_setup_packet_t request;
     327        //printf("[usb_hub] creating descriptor request\n");
     328        usb_hub_set_descriptor_request(&request);
     329
     330        //printf("[usb_hub] creating serialized descriptor\n");
     331        void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE);
     332        usb_hub_descriptor_t * descriptor;
     333        size_t received_size;
     334        int opResult;
     335        //printf("[usb_hub] starting control transaction\n");
     336        opResult = usb_drv_sync_control_read(
     337                        hc, target, &request, serialized_descriptor,
     338                        USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
     339        if (opResult != EOK) {
     340                printf("[usb_hub] failed when receiving hub descriptor, badcode = %d\n",opResult);
     341                ///\TODO memory leak will occur here!
     342                return result;
     343        }
     344        //printf("[usb_hub] deserializing descriptor\n");
     345        descriptor = usb_deserialize_hub_desriptor(serialized_descriptor);
     346        if(descriptor==NULL){
     347                printf("[usb_hub] could not deserialize descriptor \n");
     348                result->port_count = 1;///\TODO this code is only for debug!!!
     349                return result;
     350        }
     351        //printf("[usb_hub] setting port count to %d\n",descriptor->ports_count);
     352        result->port_count = descriptor->ports_count;
     353        result->attached_devs = (usb_hub_attached_device_t*)
     354            malloc((result->port_count+1) * sizeof(usb_hub_attached_device_t));
     355        int i;
     356        for(i=0;i<result->port_count+1;++i){
     357                result->attached_devs[i].devman_handle=0;
     358                result->attached_devs[i].address=0;
     359        }
     360        //printf("[usb_hub] freeing data\n");
     361        free(serialized_descriptor);
     362        free(descriptor->devices_removable);
     363        free(descriptor);
     364
     365        //finish
     366
     367        printf("[usb_hub] hub info created\n");
     368
     369        return result;
     370}
     371
     372int usb_add_hub_device(device_t *dev) {
     373        printf(NAME ": add_hub_device(handle=%d)\n", (int) dev->handle);
     374        printf("[usb_hub] hub device\n");
     375
     376        /*
     377         * We are some (probably deeply nested) hub.
     378         * Thus, assign our own operations and explore already
     379         * connected devices.
     380         */
     381
     382        //create the hub structure
     383        //get hc connection
     384        /// \TODO correct params
     385        int hc = usb_drv_hc_connect(dev, 0);
     386
     387        usb_hub_info_t * hub_info = usb_create_hub_info(dev, hc);
     388        int port;
     389        int opResult;
     390        usb_device_request_setup_packet_t request;
     391        usb_target_t target;
     392        target.address = hub_info->usb_device->address;
     393        target.endpoint = 0;
     394
     395        //get configuration descriptor
     396        // this is not fully correct - there are more configurations
     397        // and all should be checked
     398        usb_standard_device_descriptor_t std_descriptor;
     399        opResult = usb_drv_req_get_device_descriptor(hc, target.address,
     400    &std_descriptor);
     401        if(opResult!=EOK){
     402                printf("[usb_hub] could not get device descriptor, %d\n",opResult);
     403                return 1;///\TODO some proper error code needed
     404        }
     405        printf("[usb_hub] hub has %d configurations\n",std_descriptor.configuration_count);
     406        if(std_descriptor.configuration_count<1){
     407                printf("[usb_hub] THERE ARE NO CONFIGURATIONS AVAILABLE\n");
     408        }
     409        usb_standard_configuration_descriptor_t config_descriptor;
     410        opResult = usb_drv_req_get_bare_configuration_descriptor(hc,
     411        target.address, 0,
     412        &config_descriptor);
     413        if(opResult!=EOK){
     414                printf("[usb_hub] could not get configuration descriptor, %d\n",opResult);
     415                return 1;///\TODO some proper error code needed
     416        }
     417        //set configuration
     418        request.request_type = 0;
     419        request.request = USB_DEVREQ_SET_CONFIGURATION;
     420        request.index=0;
     421        request.length=0;
     422        request.value_high=0;
     423        request.value_low = config_descriptor.configuration_number;
     424        opResult = usb_drv_sync_control_write(hc, target, &request, NULL, 0);
     425        if (opResult != EOK) {
     426                printf("[usb_hub]something went wrong when setting hub`s configuration, %d\n", opResult);
     427        }
     428
     429
     430        for (port = 1; port < hub_info->port_count+1; ++port) {
     431                usb_hub_set_power_port_request(&request, port);
     432                opResult = usb_drv_sync_control_write(hc, target, &request, NULL, 0);
     433                printf("[usb_hub] powering port %d\n",port);
     434                if (opResult != EOK) {
     435                        printf("[usb_hub]something went wrong when setting hub`s %dth port\n", port);
     436                }
     437        }
     438        //ports powered, hub seems to be enabled
     439       
     440
     441        ipc_hangup(hc);
     442
     443        //add the hub to list
     444        usb_lst_append(&usb_hub_list, hub_info);
     445        printf("[usb_hub] hub info added to list\n");
     446        //(void)hub_info;
     447        usb_hub_check_hub_changes();
     448
     449        /// \TODO start the check loop, if not already started...
     450
     451        //this is just a test for port status bitmap type
     452        usb_hub_test_port_status();
     453
     454        printf("[usb_hub] hub dev added\n");
     455        printf("\taddress %d, has %d ports \n",
     456                        hub_info->usb_device->address,
     457                        hub_info->port_count);
     458        printf("\tused configuration %d\n",config_descriptor.configuration_number);
     459
     460        return EOK;
     461        //return ENOTSUP;
     462}
     463
     464//*********************************************
     465//
     466//  hub driver code, main loop
     467//
     468//*********************************************
     469
     470/**
     471 * reset the port with new device and reserve the default address
     472 * @param hc
     473 * @param port
     474 * @param target
     475 */
     476static void usb_hub_init_add_device(int hc, uint16_t port, usb_target_t target) {
     477        usb_device_request_setup_packet_t request;
     478        int opResult;
     479        printf("[usb_hub] some connection changed\n");
     480        //get default address
     481        opResult = usb_drv_reserve_default_address(hc);
     482        if (opResult != EOK) {
     483                printf("[usb_hub] cannot assign default address, it is probably used\n");
     484                return;
     485        }
     486        //reset port
     487        usb_hub_set_reset_port_request(&request, port);
     488        opResult = usb_drv_sync_control_write(
     489                        hc, target,
     490                        &request,
     491                        NULL, 0
     492                        );
     493        if (opResult != EOK) {
     494                //continue;
     495                printf("[usb_hub] something went wrong when reseting a port\n");
     496        }
     497}
     498
     499/**
     500 * finalize adding new device after port reset
     501 * @param hc
     502 * @param port
     503 * @param target
     504 */
     505static void usb_hub_finalize_add_device( usb_hub_info_t * hub,
     506                int hc, uint16_t port, usb_target_t target) {
     507
     508        int opResult;
     509        printf("[usb_hub] finalizing add device\n");
     510        opResult = usb_hub_clear_port_feature(hc, target.address,
     511            port, USB_HUB_FEATURE_C_PORT_RESET);
     512        if (opResult != EOK) {
     513                goto release;
     514        }
     515
     516        /* Request address at from host controller. */
     517        usb_address_t new_device_address = usb_drv_request_address(hc);
     518        if (new_device_address < 0) {
     519                printf("[usb_hub] failed to get free USB address\n");
     520                opResult = new_device_address;
     521                goto release;
     522        }
     523        printf("[usb_hub] setting new address\n");
     524        opResult = usb_drv_req_set_address(hc, USB_ADDRESS_DEFAULT,
     525            new_device_address);
     526
     527        if (opResult != EOK) {
     528                printf("[usb_hub] could not set address for new device\n");
     529                goto release;
     530        }
     531
     532release:
     533        printf("[usb_hub] releasing default address\n");
     534        usb_drv_release_default_address(hc);
     535        if (opResult != EOK) {
     536                return;
     537        }
     538
     539        devman_handle_t child_handle;
     540        opResult = usb_drv_register_child_in_devman(hc, hub->device,
     541            new_device_address, &child_handle);
     542        if (opResult != EOK) {
     543                printf("[usb_hub] could not start driver for new device \n");
     544                return;
     545        }
     546        hub->attached_devs[port].devman_handle = child_handle;
     547        hub->attached_devs[port].address = new_device_address;
     548
     549        opResult = usb_drv_bind_address(hc, new_device_address, child_handle);
     550        if (opResult != EOK) {
     551                printf("[usb_hub] could not assign address of device in hcd \n");
     552                return;
     553        }
     554        printf("[usb_hub] new device address %d, handle %zu\n",
     555            new_device_address, child_handle);
     556       
     557}
     558
     559/**
     560 * unregister device address in hc, close the port
     561 * @param hc
     562 * @param port
     563 * @param target
     564 */
     565static void usb_hub_removed_device(
     566    usb_hub_info_t * hub, int hc, uint16_t port, usb_target_t target) {
     567        //usb_device_request_setup_packet_t request;
     568        int opResult;
     569        //disable port
     570        /*usb_hub_set_disable_port_request(&request, port);
     571        opResult = usb_drv_sync_control_write(
     572                        hc, target,
     573                        &request,
     574                        NULL, 0
     575                        );
     576        if (opResult != EOK) {
     577                //continue;
     578                printf("[usb_hub] something went wrong when disabling a port\n");
     579        }*/
     580        /// \TODO remove device
     581
     582        hub->attached_devs[port].devman_handle=0;
     583        //close address
     584        if(hub->attached_devs[port].address!=0){
     585                opResult = usb_drv_release_address(hc,hub->attached_devs[port].address);
     586                if(opResult != EOK) {
     587                        printf("[usb_hub] could not release address of removed device: %d\n",opResult);
     588                }
     589                hub->attached_devs[port].address = 0;
     590        }else{
     591                printf("[usb_hub] this is strange, disconnected device had no address\n");
     592                //device was disconnected before it`s port was reset - return default address
     593                usb_drv_release_default_address(hc);
     594        }
     595}
     596
     597/**
     598 * process interrupts on given hub port
     599 * @param hc
     600 * @param port
     601 * @param target
     602 */
     603static void usb_hub_process_interrupt(usb_hub_info_t * hub, int hc,
     604        uint16_t port, usb_address_t address) {
     605        printf("[usb_hub] interrupt at port %d\n", port);
     606        //determine type of change
     607        usb_target_t target;
     608        target.address=address;
     609        target.endpoint=0;
     610        usb_port_status_t status;
     611        size_t rcvd_size;
     612        usb_device_request_setup_packet_t request;
     613        int opResult;
     614        usb_hub_set_port_status_request(&request, port);
     615        //endpoint 0
     616
     617        opResult = usb_drv_sync_control_read(
     618                        hc, target,
     619                        &request,
     620                        &status, 4, &rcvd_size
     621                        );
     622        if (opResult != EOK) {
     623                printf("[usb_hub] ERROR: could not get port status\n");
     624                return;
     625        }
     626        if (rcvd_size != sizeof (usb_port_status_t)) {
     627                printf("[usb_hub] ERROR: received status has incorrect size\n");
     628                return;
     629        }
     630        //something connected/disconnected
     631        if (usb_port_connect_change(&status)) {
     632                opResult = usb_hub_clear_port_feature(hc, target.address,
     633                    port, USB_HUB_FEATURE_C_PORT_CONNECTION);
     634                // TODO: check opResult
     635                if (usb_port_dev_connected(&status)) {
     636                        printf("[usb_hub] some connection changed\n");
     637                        usb_hub_init_add_device(hc, port, target);
     638                } else {
     639                        usb_hub_removed_device(hub, hc, port, target);
     640                }
     641        }
     642        //port reset
     643        if (usb_port_reset_completed(&status)) {
     644                printf("[usb_hub] port reset complete\n");
     645                if (usb_port_enabled(&status)) {
     646                        usb_hub_finalize_add_device(hub, hc, port, target);
     647                } else {
     648                        printf("[usb_hub] ERROR: port reset, but port still not enabled\n");
     649                }
     650        }
     651
     652        usb_port_set_connect_change(&status, false);
     653        usb_port_set_reset(&status, false);
     654        usb_port_set_reset_completed(&status, false);
     655        usb_port_set_dev_connected(&status, false);
     656        if (status) {
     657                printf("[usb_hub]there was some unsupported change on port %d\n",port);
     658        }
     659        /// \TODO handle other changes
     660        /// \TODO debug log for various situations
     661
     662
     663
     664        /*
     665        //configure device
     666        usb_drv_reserve_default_address(hc);
     667
     668        usb_address_t new_device_address = usb_drv_request_address(hc);
     669
     670
     671        usb_drv_release_default_address(hc);
     672         * */
     673}
     674
     675/** Check changes on all known hubs.
     676 */
     677void usb_hub_check_hub_changes(void) {
     678        /*
     679         * Iterate through all hubs.
     680         */
     681        usb_general_list_t * lst_item;
     682        for (lst_item = usb_hub_list.next;
     683                        lst_item != &usb_hub_list;
     684                        lst_item = lst_item->next) {
     685                usb_hub_info_t * hub_info = ((usb_hub_info_t*)lst_item->data);
     686                /*
     687                 * Check status change pipe of this hub.
     688                 */
     689
     690                usb_target_t target;
     691                target.address = hub_info->usb_device->address;
     692                target.endpoint = 1;/// \TODO get from endpoint descriptor
     693                printf("[usb_hub] checking changes for hub at addr %d\n",
     694                    target.address);
     695
     696                size_t port_count = hub_info->port_count;
     697
     698                /*
     699                 * Connect to respective HC.
     700                 */
     701                int hc = usb_drv_hc_connect(hub_info->device, 0);
     702                if (hc < 0) {
     703                        continue;
     704                }
     705
     706                // FIXME: count properly
     707                size_t byte_length = ((port_count+1) / 8) + 1;
     708
     709                void *change_bitmap = malloc(byte_length);
     710                size_t actual_size;
     711                usb_handle_t handle;
     712
     713                /*
     714                 * Send the request.
     715                 */
     716                int opResult = usb_drv_async_interrupt_in(hc, target,
     717                                change_bitmap, byte_length, &actual_size,
     718                                &handle);
     719
     720                usb_drv_async_wait_for(handle);
     721
     722                if (opResult != EOK) {
     723                        printf("[usb_hub] something went wrong while getting status of hub\n");
     724                        continue;
     725                }
     726                unsigned int port;
     727                for (port = 1; port < port_count+1; ++port) {
     728                        bool interrupt = (((uint8_t*) change_bitmap)[port / 8] >> (port % 8)) % 2;
     729                        if (interrupt) {
     730                                usb_hub_process_interrupt(
     731                                        hub_info, hc, port, hub_info->usb_device->address);
     732                        }
     733                }
     734
     735
     736                /*
     737                 * TODO: handle the changes.
     738                 */
     739
     740                /*
     741                 * WARNING: sample code, will not work out of the box.
     742                 * And does not contain code for checking for errors.
     743                 */
     744#if 0
     745                /*
     746                 * Before opening the port, we must acquire the default
     747                 * address.
     748                 */
     749                usb_drv_reserve_default_address(hc);
     750
     751                usb_address_t new_device_address = usb_drv_request_address(hc);
     752
     753                // TODO: open the port
     754
     755                // TODO: send request for setting address to new_device_address
     756
     757                /*
     758                 * Once new address is set, we can release the default
     759                 * address.
     760                 */
     761                usb_drv_release_default_address(hc);
     762
     763                /*
     764                 * Obtain descriptors and create match ids for devman.
     765                 */
     766
     767                // TODO: get device descriptors
     768
     769                // TODO: create match ids
     770
     771                // TODO: add child device
     772
     773                // child_device_register sets the device handle
     774                // TODO: store it here
     775                devman_handle_t new_device_handle = 0;
     776
     777                /*
     778                 * Inform the HC that the new device has devman handle
     779                 * assigned.
     780                 */
     781                usb_drv_bind_address(hc, new_device_address, new_device_handle);
     782
     783                /*
     784                 * That's all.
     785                 */
     786#endif
     787
     788
     789                /*
     790                 * Hang-up the HC-connected phone.
     791                 */
     792                ipc_hangup(hc);
     793        }
     794}
    259795
    260796/**
  • uspace/lib/usb/include/usb/hcdhubd.h

    r8dd039a r557c7d0  
    207207int usb_hc_add_child_device(device_t *, const char *, const char *, bool);
    208208
    209 
    210 /**
    211  * @}
    212  */
    213 
    214209#endif
Note: See TracChangeset for help on using the changeset viewer.