Changeset 399a13c in mainline


Ignore:
Timestamp:
2011-05-30T13:50:33Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
17d1542
Parents:
a5fc431 (diff), 8971926 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Development changes

Files:
24 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    ra5fc431 r399a13c  
    570570
    571571% USB release build (less logging)
    572 ! CONFIG_USB_RELEASE_BUILD (n/y)
     572! CONFIG_USB_RELEASE_BUILD (y/n)
    573573
    574574% Start virtual USB host controller
    … …  
    576576
    577577% Polling UHCI & OHCI (no interrupts)
    578 ! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (y/n)
     578! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (n/y)
    579579
    580580% Run devman in kconsole (not recommended)

  • uspace/drv/ohci/root_hub.c

    ra5fc431 r399a13c  
    5757        .device_version = 0,
    5858        .length = sizeof (usb_standard_device_descriptor_t),
    59         /// \TODO this value is guessed
    6059        .max_packet_size = 8,
    6160        .vendor_id = 0x16db,
    … …  
    117116 */
    118117static const uint32_t hub_clear_feature_by_writing_one_mask =
    119    RHS_CLEAR_PORT_POWER;
     118    RHS_CLEAR_PORT_POWER;
    120119
    121120/**
    … …  
    412411        request->transfered_size = 4;
    413412        uint32_t data = instance->registers->rh_port_status[port - 1];
    414         memcpy(request->data_buffer,&data,4);
     413        memcpy(request->data_buffer, &data, 4);
    415414#if 0
    416415        int i;
    … …  
    445444        uint32_t data = mask & instance->registers->rh_status;
    446445        //uint32_buffer[0] = mask & instance->registers->rh_status;
    447         memcpy(request->data_buffer,&data,4);
     446        memcpy(request->data_buffer, &data, 4);
    448447
    449448        return EOK;
    … …  
    468467
    469468        usb_hub_bm_request_type_t request_type = request_packet->request_type;
    470         if (buffer_size < 4/*request_packet->length*/) {///\TODO
     469        if (buffer_size < 4) {
    471470                usb_log_warning("requested more data than buffer size\n");
    472471                return EINVAL;
    … …  
    499498            | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
    500499        bzero(bitmap, instance->interrupt_mask_size);
    501         if ((instance->registers->rh_status & mask) !=0 ) {
     500        if ((instance->registers->rh_status & mask) != 0) {
    502501                bitmap[0] = 1;
    503502        }
    … …  
    678677            (instance->registers->rh_port_status[port - 1] | (1 << feature))
    679678            & (~port_clear_feature_valid_mask);
    680         /// \TODO any error?
    681 
    682679        return EOK;
    683680}
    … …  
    707704            & (~port_clear_feature_valid_mask))
    708705            | (1 << feature);
    709         /// \TODO any error?
    710706
    711707        return EOK;
    … …  
    925921 * @return
    926922 */
    927 static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request) {
     923static int process_interrupt_mask_in_instance(rh_t *instance,
     924    usb_transfer_batch_t * request) {
    928925        memcpy(request->data_buffer, instance->interrupt_buffer,
    929926            instance->interrupt_mask_size);
    … …  
    945942 * @return
    946943 */
    947 static bool is_zeros(void * buffer, size_t size) {
     944static bool is_zeros(void *buffer, size_t size) {
    948945        if (!buffer) return true;
    949946        if (!size) return true;

  • uspace/drv/uhci-rhd/port.h

    ra5fc431 r399a13c  
    5555
    5656/** UHCI port structure */
    57 typedef struct uhci_port
    58 {
     57typedef struct uhci_port {
    5958        const char *id_string;
    6059        port_status_t *address;
    … …  
    6867
    6968int uhci_port_init(
    70   uhci_port_t *port, port_status_t *address, unsigned number,
    71   unsigned usec, ddf_dev_t *rh);
     69    uhci_port_t *port, port_status_t *address, unsigned number,
     70    unsigned usec, ddf_dev_t *rh);
    7271
    7372void uhci_port_fini(uhci_port_t *port);

  • uspace/drv/usbhid/generic/hiddev.c

    ra5fc431 r399a13c  
    9999        usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    100100       
    101         usb_log_debug2("hid_dev: %p, Max input report size (%d).\n",
     101        usb_log_debug2("hid_dev: %p, Max input report size (%zu).\n",
    102102            hid_dev, hid_dev->max_input_report_size);
    103103       
    … …  
    226226        }
    227227       
    228         usb_log_debug("HID function created. Handle: %d\n", fun->handle);
     228        usb_log_debug("HID function created. Handle: %" PRIun "\n", fun->handle);
    229229       
    230230        return EOK;

  • uspace/drv/usbhid/kbd/kbddev.c

    ra5fc431 r399a13c  
    798798        }
    799799       
    800         usb_log_debug("%s function created. Handle: %d\n", HID_KBD_FUN_NAME,
    801             fun->handle);
     800        usb_log_debug("%s function created. Handle: %" PRIun "\n",
     801            HID_KBD_FUN_NAME, fun->handle);
    802802       
    803803        usb_log_debug("Adding DDF function to class %s...\n",

  • uspace/drv/usbhid/multimedia/multimedia.c

    ra5fc431 r399a13c  
    211211        }
    212212       
    213         usb_log_debug("%s function created. Handle: %d\n", NAME, fun->handle);
     213        usb_log_debug("%s function created (jandle: %" PRIun ").\n",
     214            NAME, fun->handle);
    214215       
    215216        rc = ddf_fun_add_to_class(fun, "keyboard");

  • uspace/drv/usbhub/main.c

    ra5fc431 r399a13c  
    8787
    8888        usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
    89        
     89
    9090        return usb_driver_main(&usb_hub_driver);
    9191}

  • uspace/drv/usbhub/port_status.h

    ra5fc431 r399a13c  
    6464 */
    6565static inline void usb_hub_set_port_status_request(
    66         usb_device_request_setup_packet_t * request, uint16_t port
    67         ) {
     66    usb_device_request_setup_packet_t *request, uint16_t port) {
    6867        request->index = port;
    6968        request->request_type = USB_HUB_REQ_TYPE_GET_PORT_STATUS;
    … …  
    7978 */
    8079static inline void usb_hub_set_hub_status_request(
    81         usb_device_request_setup_packet_t * request
    82         ) {
     80    usb_device_request_setup_packet_t *request) {
    8381        request->index = 0;
    8482        request->request_type = USB_HUB_REQ_TYPE_GET_HUB_STATUS;
    … …  
    9593static inline usb_device_request_setup_packet_t *
    9694usb_hub_create_port_status_request(uint16_t port) {
    97         usb_device_request_setup_packet_t * result =
    98                 malloc(sizeof(usb_device_request_setup_packet_t));
     95        usb_device_request_setup_packet_t *result =
     96            malloc(sizeof (usb_device_request_setup_packet_t));
    9997        usb_hub_set_port_status_request(result, port);
    10098        return result;
    … …  
    108106 */
    109107static inline void usb_hub_set_enable_port_feature_request(
    110         usb_device_request_setup_packet_t * request, uint16_t port,
    111         uint16_t feature_selector
    112         ) {
     108    usb_device_request_setup_packet_t *request, uint16_t port,
     109    uint16_t feature_selector) {
    113110        request->index = port;
    114111        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    125122 */
    126123static inline void usb_hub_set_disable_port_feature_request(
    127         usb_device_request_setup_packet_t * request, uint16_t port,
    128         uint16_t feature_selector
    129         ) {
     124    usb_device_request_setup_packet_t *request, uint16_t port,
     125    uint16_t feature_selector
     126    ) {
    130127        request->index = port;
    131128        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    141138 */
    142139static inline void usb_hub_set_enable_port_request(
    143         usb_device_request_setup_packet_t * request, uint16_t port
    144         ) {
     140    usb_device_request_setup_packet_t *request, uint16_t port
     141    ) {
    145142        request->index = port;
    146143        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    157154static inline usb_device_request_setup_packet_t *
    158155usb_hub_create_enable_port_request(uint16_t port) {
    159         usb_device_request_setup_packet_t * result =
    160                 malloc(sizeof(usb_device_request_setup_packet_t));
     156        usb_device_request_setup_packet_t *result =
     157            malloc(sizeof (usb_device_request_setup_packet_t));
    161158        usb_hub_set_enable_port_request(result, port);
    162159        return result;
    … …  
    169166 */
    170167static inline void usb_hub_set_disable_port_request(
    171         usb_device_request_setup_packet_t * request, uint16_t port
    172         ) {
     168    usb_device_request_setup_packet_t *request, uint16_t port
     169    ) {
    173170        request->index = port;
    174171        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    185182static inline usb_device_request_setup_packet_t *
    186183usb_hub_create_disable_port_request(uint16_t port) {
    187         usb_device_request_setup_packet_t * result =
    188                 malloc(sizeof(usb_device_request_setup_packet_t));
     184        usb_device_request_setup_packet_t *result =
     185            malloc(sizeof (usb_device_request_setup_packet_t));
    189186        usb_hub_set_disable_port_request(result, port);
    190187        return result;
    … …  
    197194 */
    198195static inline void usb_hub_set_reset_port_request(
    199         usb_device_request_setup_packet_t * request, uint16_t port
    200         ) {
     196    usb_device_request_setup_packet_t *request, uint16_t port
     197    ) {
    201198        request->index = port;
    202199        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    213210static inline usb_device_request_setup_packet_t *
    214211usb_hub_create_reset_port_request(uint16_t port) {
    215         usb_device_request_setup_packet_t * result =
    216                 malloc(sizeof(usb_device_request_setup_packet_t));
     212        usb_device_request_setup_packet_t *result =
     213            malloc(sizeof (usb_device_request_setup_packet_t));
    217214        usb_hub_set_reset_port_request(result, port);
    218215        return result;
    … …  
    225222 */
    226223static inline void usb_hub_set_power_port_request(
    227         usb_device_request_setup_packet_t * request, uint16_t port
    228         ) {
     224    usb_device_request_setup_packet_t *request, uint16_t port
     225    ) {
    229226        request->index = port;
    230227        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    240237 */
    241238static inline void usb_hub_unset_power_port_request(
    242         usb_device_request_setup_packet_t * request, uint16_t port
    243         ) {
     239    usb_device_request_setup_packet_t *request, uint16_t port
     240    ) {
    244241        request->index = port;
    245242        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    257254 */
    258255static inline bool usb_port_is_status(usb_port_status_t status, int idx) {
    259         return (status&(1 << idx))!=0;
     256        return (status & (1 << idx)) != 0;
    260257}
    261258
    … …  
    268265 */
    269266static inline void usb_port_status_set_bit(
    270         usb_port_status_t * status, int idx, bool value) {
     267    usb_port_status_t * status, int idx, bool value) {
    271268        (*status) = value ?
    272                 ((*status) | (1 << (idx))) :
    273                 ((*status)&(~(1 << (idx))));
     269            ((*status) | (1 << (idx))) :
     270            ((*status)&(~(1 << (idx))));
    274271}
    275272
    … …  
    282279 */
    283280static inline bool usb_hub_is_status(usb_hub_status_t status, int idx) {
    284         return (status&(1 << idx))!=0;
     281        return (status & (1 << idx)) != 0;
    285282}
    286283
    … …  
    293290 */
    294291static inline void usb_hub_status_set_bit(
    295         usb_hub_status_t * status, int idx, bool value) {
     292    usb_hub_status_t *status, int idx, bool value) {
    296293        (*status) = value ?
    297                 ((*status) | (1 << (idx))) :
    298                 ((*status)&(~(1 << (idx))));
    299 }
    300 
    301 
    302 #if 0
    303 /**
    304  * connection status geter for port status
    305  *
    306  * @param status
    307  * @return true if there is something connected
    308  */
    309 static inline bool usb_port_dev_connected(usb_port_status_t * status) {
    310         return usb_port_get_bit(status, 0);
    311 }
    312 
    313 /**
    314  * set device connected bit in port status
    315  *
    316  * @param status
    317  * @param connected value of the bit
    318  */
    319 static inline void usb_port_set_dev_connected(usb_port_status_t * status, bool connected) {
    320         usb_port_set_bit(status, 0, connected);
    321 }
    322 
    323 //port enabled
    324 
    325 /**
    326  * port enabled getter for port status
    327  *
    328  * @param status
    329  * @return true if the port is enabled
    330  */
    331 static inline bool usb_port_enabled(usb_port_status_t * status) {
    332         return usb_port_get_bit(status, 1);
    333 }
    334 
    335 /**
    336  * set port enabled bit in port status
    337  *
    338  * @param status
    339  * @param enabled value of the bit
    340  */
    341 static inline void usb_port_set_enabled(usb_port_status_t * status, bool enabled) {
    342         usb_port_set_bit(status, 1, enabled);
    343 }
    344 
    345 //port suspended
    346 /**
    347  * port suspended getter for port status
    348  *
    349  * @param status
    350  * @return true if port is suspended
    351  */
    352 static inline bool usb_port_suspended(usb_port_status_t * status) {
    353         return usb_port_get_bit(status, 2);
    354 }
    355 
    356 /**
    357  * set port suspended bit in port status
    358  *
    359  * @param status
    360  * @param suspended value of the bit
    361  */
    362 static inline void usb_port_set_suspended(usb_port_status_t * status, bool suspended) {
    363         usb_port_set_bit(status, 2, suspended);
    364 }
    365 
    366 //over currect
    367 /**
    368  * over current condition indicator getter for port status
    369  *
    370  * @param status
    371  * @return true if there is opver-current condition on the hub
    372  */
    373 static inline bool usb_port_over_current(usb_port_status_t * status) {
    374         return usb_port_get_bit(status, 3);
    375 }
    376 
    377 /**
    378  * set over current indicator bit in port status
    379  *
    380  * @param status
    381  * @param value value of the bit
    382  */
    383 static inline void usb_port_set_over_current(usb_port_status_t * status, bool value) {
    384         usb_port_set_bit(status, 3, value);
    385 }
    386 
    387 //port reset
    388 /**
    389  * port reset indicator getter for port status
    390  *
    391  * @param status
    392  * @return true if port is reset
    393  */
    394 static inline bool usb_port_reset(usb_port_status_t * status) {
    395         return usb_port_get_bit(status, 4);
    396 }
    397 
    398 /**
    399  * set port reset bit in port status
    400  *
    401  * @param status
    402  * @param value value of the bit
    403  */
    404 static inline void usb_port_set_reset(usb_port_status_t * status, bool value) {
    405         usb_port_set_bit(status, 4, value);
    406 }
    407 
    408 //powered
    409 /**
    410  * power state getter for port status
    411  *
    412  * @param status
    413  * @return true if port is powered
    414  */
    415 static inline bool usb_port_powered(usb_port_status_t * status) {
    416         return usb_port_get_bit(status, 8);
    417 }
    418 
    419 /**
    420  * set port powered bit in port status
    421  *
    422  * @param status
    423  * @param powered value of the bit
    424  */
    425 static inline void usb_port_set_powered(usb_port_status_t * status, bool powered) {
    426         usb_port_set_bit(status, 8, powered);
    427 }
    428 
    429 #endif
    430 
    431 //low speed device attached
     294            ((*status) | (1 << (idx))) :
     295            ((*status)&(~(1 << (idx))));
     296}
     297
    432298/**
    433299 * low speed device on the port indicator
    … …  
    446312 * @param low_speed value of the bit
    447313 */
    448 static inline void usb_port_set_low_speed(usb_port_status_t * status, bool low_speed) {
     314static inline void usb_port_set_low_speed(usb_port_status_t *status, bool low_speed) {
    449315        usb_port_status_set_bit(status, 9, low_speed);
    450316}
    451317
    452318//high speed device attached
     319
    453320/**
    454321 * high speed device on the port indicator
    … …  
    467334 * @param high_speed value of the bit
    468335 */
    469 static inline void usb_port_set_high_speed(usb_port_status_t * status, bool high_speed) {
     336static inline void usb_port_set_high_speed(usb_port_status_t *status, bool high_speed) {
    470337        usb_port_status_set_bit(status, 10, high_speed);
    471338}
    … …  
    485352}
    486353
    487 #if 0
    488 //connect change
    489 /**
    490  * port connect change indicator
    491  *
    492  * @param status
    493  * @return true if connection has changed
    494  */
    495 static inline bool usb_port_connect_change(usb_port_status_t * status) {
    496         return usb_port_get_bit(status, 16);
    497 }
    498 
    499 /**
    500  * set connection change bit in port status
    501  * @param status
    502  * @param change value of the bit
    503  */
    504 static inline void usb_port_set_connect_change(usb_port_status_t * status, bool change) {
    505         usb_port_set_bit(status, 16, change);
    506 }
    507 
    508 //port enable change
    509 /**
    510  * port enable change for port status
    511  *
    512  * @param status
    513  * @return true if the port has been enabled/disabled
    514  */
    515 static inline bool usb_port_enabled_change(usb_port_status_t * status) {
    516         return usb_port_get_bit(status, 17);
    517 }
    518 
    519 /**
    520  * set port enable change bit in port status
    521  *
    522  * @param status
    523  * @param change value of the bit
    524  */
    525 static inline void usb_port_set_enabled_change(usb_port_status_t * status, bool change) {
    526         usb_port_set_bit(status, 17, change);
    527 }
    528 
    529 //suspend change
    530 /**
    531  * port suspend change for port status
    532  *
    533  * @param status
    534  * @return ture if suspend status has changed
    535  */
    536 static inline bool usb_port_suspend_change(usb_port_status_t * status) {
    537         return usb_port_get_bit(status, 18);
    538 }
    539 
    540 /**
    541  * set port suspend change bit in port status
    542  *
    543  * @param status
    544  * @param change value of the bit
    545  */
    546 static inline void usb_port_set_suspend_change(usb_port_status_t * status, bool change) {
    547         usb_port_set_bit(status, 18, change);
    548 }
    549 
    550 //over current change
    551 /**
    552  * over current change indicator
    553  *
    554  * @param status
    555  * @return true if over-current condition on port has changed
    556  */
    557 static inline bool usb_port_overcurrent_change(usb_port_status_t * status) {
    558         return usb_port_get_bit(status, 19);
    559 }
    560 
    561 /**
    562  * set port over current change bit in port status
    563  *
    564  * @param status
    565  * @param change value of the bit
    566  */
    567 static inline void usb_port_set_overcurrent_change(usb_port_status_t * status, bool change) {
    568         usb_port_set_bit(status, 19, change);
    569 }
    570 
    571 //reset change
    572 /**
    573  * port reset change indicator
    574  * @param status
    575  * @return true if port has been reset
    576  */
    577 static inline bool usb_port_reset_completed(usb_port_status_t * status) {
    578         return usb_port_get_bit(status, 20);
    579 }
    580 
    581 /**
    582  * set port reset completed bit in port status
    583  *
    584  * @param status
    585  * @param change value of the bit
    586  */
    587 static inline void usb_port_set_reset_completed(usb_port_status_t * status, bool completed) {
    588         usb_port_set_bit(status, 20, completed);
    589 }
    590 
    591 //local power status
    592 /**
    593  * local power lost indicator for hub status
    594  *
    595  * @param status
    596  * @return true if hub is not powered
    597  */
    598 static inline bool usb_hub_local_power_lost(usb_hub_status_t * status) {
    599         return usb_hub_get_bit(status, 0);
    600 }
    601 
    602 /**
    603  * set hub power lost bit in hub status
    604  *
    605  * @param status
    606  * @param change value of the bit
    607  */
    608 static inline void usb_hub_set_local_power_lost(usb_port_status_t * status,
    609         bool power_lost) {
    610         usb_hub_set_bit(status, 0, power_lost);
    611 }
    612 
    613 //over current ocndition
    614 /**
    615  * hub over-current indicator
    616  *
    617  * @param status
    618  * @return true if over-current condition occurred on hub
    619  */
    620 static inline bool usb_hub_over_current(usb_hub_status_t * status) {
    621         return usb_hub_get_bit(status, 1);
    622 }
    623 
    624 /**
    625  * set hub over current bit in hub status
    626  *
    627  * @param status
    628  * @param change value of the bit
    629  */
    630 static inline void usb_hub_set_over_current(usb_port_status_t * status,
    631         bool over_current) {
    632         usb_hub_set_bit(status, 1, over_current);
    633 }
    634 
    635 //local power change
    636 /**
    637  * hub power change indicator
    638  *
    639  * @param status
    640  * @return true if local power status has been changed - power has been
    641  * dropped or re-established
    642  */
    643 static inline bool usb_hub_local_power_change(usb_hub_status_t * status) {
    644         return usb_hub_get_bit(status, 16);
    645 }
    646 
    647 /**
    648  * set hub power change bit in hub status
    649  *
    650  * @param status
    651  * @param change value of the bit
    652  */
    653 static inline void usb_hub_set_local_power_change(usb_port_status_t * status,
    654         bool change) {
    655         usb_hub_set_bit(status, 16, change);
    656 }
    657 
    658 //local power status
    659 /**
    660  * hub over-current condition change indicator
    661  *
    662  * @param status
    663  * @return true if over-current condition has changed
    664  */
    665 static inline bool usb_hub_over_current_change(usb_hub_status_t * status) {
    666         return usb_hub_get_bit(status, 17);
    667 }
    668 
    669 /**
    670  * set hub over current change bit in hub status
    671  *
    672  * @param status
    673  * @param change value of the bit
    674  */
    675 static inline void usb_hub_set_over_current_change(usb_port_status_t * status,
    676         bool change) {
    677         usb_hub_set_bit(status, 17, change);
    678 }
    679 #endif
    680354
    681355

  • uspace/drv/usbhub/ports.c

    ra5fc431 r399a13c  
    4747#include "port_status.h"
    4848
    49 
    5049/** Information for fibril for device discovery. */
    5150struct add_device_phase1 {
    … …  
    6564 * any function here and must be cleared by hand
    6665 */
    67 static const int non_handled_changes[] =  {
     66static const int non_handled_changes[] = {
    6867        USB_HUB_FEATURE_C_PORT_ENABLE,
    6968        USB_HUB_FEATURE_C_PORT_SUSPEND
    … …  
    7170
    7271static void usb_hub_removed_device(
    73         usb_hub_info_t * hub, uint16_t port);
    74 
    75 static void usb_hub_port_reset_completed(usb_hub_info_t * hub,
    76         uint16_t port, uint32_t status);
    77 
    78 static void usb_hub_port_over_current(usb_hub_info_t * hub,
    79         uint16_t port, uint32_t status);
     72    usb_hub_info_t *hub, uint16_t port);
     73
     74static void usb_hub_port_reset_completed(usb_hub_info_t *hub,
     75    uint16_t port, uint32_t status);
     76
     77static void usb_hub_port_over_current(usb_hub_info_t *hub,
     78    uint16_t port, uint32_t status);
    8079
    8180static int get_port_status(usb_pipe_t *ctrl_pipe, size_t port,
    … …  
    9695 * @param port port number, starting from 1
    9796 */
    98 void usb_hub_process_interrupt(usb_hub_info_t * hub,
    99         uint16_t port) {
    100         usb_log_debug("interrupt at port %zu\n", (size_t) port);
     97void usb_hub_process_interrupt(usb_hub_info_t *hub,
     98    uint16_t port) {
     99        usb_log_debug("Interrupt at port %zu\n", (size_t) port);
    101100        //determine type of change
    102101        //usb_pipe_t *pipe = hub->control_pipe;
    … …  
    134133        if (usb_port_is_status(status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT)) {
    135134                //check if it was not auto-resolved
    136                 usb_log_debug("overcurrent change on port\n");
     135                usb_log_debug("Overcurrent change on port\n");
    137136                usb_hub_port_over_current(hub, port, status);
    138137        }
    … …  
    141140                usb_hub_port_reset_completed(hub, port, status);
    142141        }
    143         usb_log_debug("status x%x : %d\n ", status, status);
     142        usb_log_debug("Status x%x : %d\n ", status, status);
    144143
    145144        usb_port_status_set_bit(
    146             &status, USB_HUB_FEATURE_C_PORT_CONNECTION,false);
     145            &status, USB_HUB_FEATURE_C_PORT_CONNECTION, false);
    147146        usb_port_status_set_bit(
    148             &status, USB_HUB_FEATURE_C_PORT_RESET,false);
     147            &status, USB_HUB_FEATURE_C_PORT_RESET, false);
    149148        usb_port_status_set_bit(
    150             &status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT,false);
    151        
     149            &status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT, false);
     150
    152151        //clearing not yet handled changes     
    153152        unsigned int feature_idx;
    154         for(feature_idx = 0;feature_idx<non_handled_changes_count;
    155             ++feature_idx){
     153        for (feature_idx = 0;
     154            feature_idx < non_handled_changes_count;
     155            ++feature_idx) {
    156156                unsigned int bit_idx = non_handled_changes[feature_idx];
    157                 if(status & (1<<bit_idx)){
     157                if (status & (1 << bit_idx)) {
    158158                        usb_log_info(
    159                             "there was not yet handled change on port %d: %d"
     159                            "There was not yet handled change on port %d: %d"
    160160                            ";clearing it\n",
    161                         port, bit_idx);
     161                            port, bit_idx);
    162162                        int opResult = usb_hub_clear_port_feature(
    163163                            hub->control_pipe,
    … …  
    165165                        if (opResult != EOK) {
    166166                                usb_log_warning(
    167                                     "could not clear port flag %d: %d\n",
    168                                     bit_idx, opResult
     167                                    "Could not clear port flag %d: %s\n",
     168                                    bit_idx, str_error(opResult)
    169169                                    );
    170170                        }
    171171                        usb_port_status_set_bit(
    172                             &status, bit_idx,false);
     172                            &status, bit_idx, false);
    173173                }
    174174        }
    175         if(status>>16){
    176                 usb_log_info("there is still some unhandled change %X\n",
     175        if (status >> 16) {
     176                usb_log_info("There is still some unhandled change %X\n",
    177177                    status);
    178178        }
    179179}
    180 
    181180
    182181/**
    … …  
    190189 */
    191190static void usb_hub_removed_device(
    192         usb_hub_info_t * hub, uint16_t port) {
     191    usb_hub_info_t *hub, uint16_t port) {
    193192
    194193        int opResult = usb_hub_clear_port_feature(hub->control_pipe,
    195                 port, USB_HUB_FEATURE_C_PORT_CONNECTION);
     194            port, USB_HUB_FEATURE_C_PORT_CONNECTION);
    196195        if (opResult != EOK) {
    197                 usb_log_warning("could not clear port-change-connection flag\n");
     196                usb_log_warning("Could not clear port-change-connection flag\n");
    198197        }
    199198        /** \TODO remove device from device manager - not yet implemented in
    … …  
    202201
    203202        //close address
    204         if(hub->ports[port].attached_device.address >= 0){
    205                 /*uncomment this code to use it when DDF allows device removal
    206                 opResult = usb_hc_unregister_device(
    207                         &hub->connection,
    208                         hub->attached_devs[port].address);
    209                 if(opResult != EOK) {
    210                         dprintf(USB_LOG_LEVEL_WARNING, "could not release "
    211                                 "address of "
    212                             "removed device: %d", opResult);
    213                 }
    214                 hub->attached_devs[port].address = 0;
    215                 hub->attached_devs[port].handle = 0;
    216                  */
     203
     204        usb_hub_port_t *the_port = hub->ports + port;
     205
     206        fibril_mutex_lock(&hub->port_mutex);
     207
     208        if (the_port->attached_device.address >= 0) {
     209                usb_log_warning("Device unplug on `%s' (port %zu): " \
     210                    "not implemented.\n", hub->usb_device->ddf_dev->name,
     211                    (size_t) port);
     212                the_port->attached_device.address = -1;
     213                the_port->attached_device.handle = 0;
    217214        } else {
    218215                usb_log_warning("Device removed before being registered.\n");
    … …  
    223220                 * port reset callback from new device wrapper.
    224221                 */
    225                 usb_hub_port_t *the_port = hub->ports + port;
    226222                fibril_mutex_lock(&the_port->reset_mutex);
    227223                the_port->reset_completed = true;
    … …  
    230226                fibril_mutex_unlock(&the_port->reset_mutex);
    231227        }
    232 }
    233 
     228
     229        fibril_mutex_unlock(&hub->port_mutex);
     230}
    234231
    235232/**
    … …  
    242239 * @param status
    243240 */
    244 static void usb_hub_port_reset_completed(usb_hub_info_t * hub,
    245         uint16_t port, uint32_t status){
     241static void usb_hub_port_reset_completed(usb_hub_info_t *hub,
     242    uint16_t port, uint32_t status) {
    246243        usb_log_debug("Port %zu reset complete.\n", (size_t) port);
    247244        if (usb_port_is_status(status, USB_HUB_FEATURE_PORT_ENABLE)) {
    … …  
    275272 * @param port port number, starting from 1
    276273 */
    277 static void usb_hub_port_over_current(usb_hub_info_t * hub,
    278         uint16_t port, uint32_t status) {
     274static void usb_hub_port_over_current(usb_hub_info_t *hub,
     275    uint16_t port, uint32_t status) {
    279276        int opResult;
    280         if(usb_port_is_status(status, USB_HUB_FEATURE_PORT_OVER_CURRENT)){
     277        if (usb_port_is_status(status, USB_HUB_FEATURE_PORT_OVER_CURRENT)) {
    281278                opResult = usb_hub_clear_port_feature(hub->control_pipe,
    282                         port, USB_HUB_FEATURE_PORT_POWER);
     279                    port, USB_HUB_FEATURE_PORT_POWER);
    283280                if (opResult != EOK) {
    284                         usb_log_error("cannot power off port %d;  %d\n",
    285                                 port, opResult);
     281                        usb_log_error("Cannot power off port %d; %s\n",
     282                            port, str_error(opResult));
    286283                }
    287         }else{
     284        } else {
    288285                opResult = usb_hub_set_port_feature(hub->control_pipe,
    289                         port, USB_HUB_FEATURE_PORT_POWER);
     286                    port, USB_HUB_FEATURE_PORT_POWER);
    290287                if (opResult != EOK) {
    291                         usb_log_error("cannot power on port %d;  %d\n",
    292                                 port, opResult);
     288                        usb_log_error("Cannot power on port %d; %s\n",
     289                            port, str_error(opResult));
    293290                }
    294291        }
    … …  
    303300 */
    304301static int get_port_status(usb_pipe_t *ctrl_pipe, size_t port,
    305     usb_port_status_t *status)
    306 {
     302    usb_port_status_t *status) {
    307303        size_t recv_size;
    308304        usb_device_request_setup_packet_t request;
    … …  
    311307        usb_hub_set_port_status_request(&request, port);
    312308        int rc = usb_pipe_control_read(ctrl_pipe,
    313             &request, sizeof(usb_device_request_setup_packet_t),
    314             &status_tmp, sizeof(status_tmp), &recv_size);
     309            &request, sizeof (usb_device_request_setup_packet_t),
     310            &status_tmp, sizeof (status_tmp), &recv_size);
    315311        if (rc != EOK) {
    316312                return rc;
    … …  
    337333 * @return Error code.
    338334 */
    339 static int enable_port_callback(int port_no, void *arg)
    340 {
     335static int enable_port_callback(int port_no, void *arg) {
    341336        usb_hub_info_t *hub = arg;
    342337        int rc;
    … …  
    346341        usb_hub_set_reset_port_request(&request, port_no);
    347342        rc = usb_pipe_control_write(hub->control_pipe,
    348             &request, sizeof(request), NULL, 0);
     343            &request, sizeof (request), NULL, 0);
    349344        if (rc != EOK) {
    350345                usb_log_warning("Port reset failed: %s.\n", str_error(rc));
    … …  
    376371 * @return 0 Always.
    377372 */
    378 static int add_device_phase1_worker_fibril(void *arg)
    379 {
     373static int add_device_phase1_worker_fibril(void *arg) {
    380374        struct add_device_phase1 *data
    381375            = (struct add_device_phase1 *) arg;
    … …  
    396390        }
    397391
     392        fibril_mutex_lock(&data->hub->port_mutex);
    398393        data->hub->ports[data->port].attached_device.handle = child_handle;
    399394        data->hub->ports[data->port].attached_device.address = new_address;
     395        fibril_mutex_unlock(&data->hub->port_mutex);
    400396
    401397        usb_log_info("Detected new device on `%s' (port %zu), "
    … …  
    407403        free(arg);
    408404
     405        fibril_mutex_lock(&data->hub->pending_ops_mutex);
     406        assert(data->hub->pending_ops_count > 0);
     407        data->hub->pending_ops_count--;
     408        fibril_condvar_signal(&data->hub->pending_ops_cv);
     409        fibril_mutex_unlock(&data->hub->pending_ops_mutex);
     410
     411
    409412        return EOK;
    410413}
    411 
    412414
    413415/** Start device adding when connection change is detected.
    … …  
    421423 */
    422424static int create_add_device_fibril(usb_hub_info_t *hub, size_t port,
    423     usb_speed_t speed)
    424 {
     425    usb_speed_t speed) {
    425426        struct add_device_phase1 *data
    426             = malloc(sizeof(struct add_device_phase1));
     427            = malloc(sizeof (struct add_device_phase1));
    427428        if (data == NULL) {
    428429                return ENOMEM;
    … …  
    452453                return ENOMEM;
    453454        }
     455        fibril_mutex_lock(&hub->pending_ops_mutex);
     456        hub->pending_ops_count++;
     457        fibril_mutex_unlock(&hub->pending_ops_mutex);
    454458        fibril_add_ready(fibril);
    455459

  • uspace/drv/usbhub/ports.h

    ra5fc431 r399a13c  
    7070
    7171
    72 void usb_hub_process_interrupt(usb_hub_info_t * hub,
     72void usb_hub_process_interrupt(usb_hub_info_t *hub,
    7373        uint16_t port);
    7474

  • uspace/drv/usbhub/usbhub.c

    ra5fc431 r399a13c  
    5656
    5757
    58 static usb_hub_info_t * usb_hub_info_create(usb_device_t * usb_dev);
    59 
    60 static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info);
    61 
    62 static int usb_hub_set_configuration(usb_hub_info_t * hub_info);
    63 
    64 static int usb_hub_start_hub_fibril(usb_hub_info_t * hub_info);
    65 
    66 static int usb_process_hub_over_current(usb_hub_info_t * hub_info,
     58static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev);
     59
     60static int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info);
     61
     62static int usb_hub_set_configuration(usb_hub_info_t *hub_info);
     63
     64static int usb_hub_start_hub_fibril(usb_hub_info_t *hub_info);
     65
     66static int usb_process_hub_over_current(usb_hub_info_t *hub_info,
    6767    usb_hub_status_t status);
    6868
    69 static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
     69static int usb_process_hub_local_power_change(usb_hub_info_t *hub_info,
    7070    usb_hub_status_t status);
    7171
    72 static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info);
    73 
    74 static void usb_hub_polling_terminted_callback(usb_device_t * device,
    75     bool was_error, void * data);
     72static void usb_hub_process_global_interrupt(usb_hub_info_t *hub_info);
     73
     74static void usb_hub_polling_terminated_callback(usb_device_t *device,
     75    bool was_error, void *data);
    7676
    7777
    … …  
    9090 * @return error code
    9191 */
    92 int usb_hub_add_device(usb_device_t * usb_dev) {
     92int usb_hub_add_device(usb_device_t *usb_dev) {
    9393        if (!usb_dev) return EINVAL;
    94         usb_hub_info_t * hub_info = usb_hub_info_create(usb_dev);
     94        usb_hub_info_t *hub_info = usb_hub_info_create(usb_dev);
    9595        //create hc connection
    9696        usb_log_debug("Initializing USB wire abstraction.\n");
    … …  
    9999            hub_info->usb_device->ddf_dev);
    100100        if (opResult != EOK) {
    101                 usb_log_error("could not initialize connection to device, "
    102                     "errno %d\n",
    103                     opResult);
     101                usb_log_error("Could not initialize connection to device, "
     102                    " %s\n",
     103                    str_error(opResult));
    104104                free(hub_info);
    105105                return opResult;
    … …  
    109109        opResult = usb_hub_set_configuration(hub_info);
    110110        if (opResult != EOK) {
    111                 usb_log_error("could not set hub configuration, errno %d\n",
    112                     opResult);
     111                usb_log_error("Could not set hub configuration, %s\n",
     112                    str_error(opResult));
    113113                free(hub_info);
    114114                return opResult;
    … …  
    117117        opResult = usb_hub_process_hub_specific_info(hub_info);
    118118        if (opResult != EOK) {
    119                 usb_log_error("could process hub specific info, errno %d\n",
    120                     opResult);
     119                usb_log_error("Could process hub specific info, %s\n",
     120                    str_error(opResult));
    121121                free(hub_info);
    122122                return opResult;
    … …  
    135135
    136136        opResult = usb_hub_start_hub_fibril(hub_info);
    137         if(opResult!=EOK)
     137        if (opResult != EOK)
    138138                free(hub_info);
    139139        return opResult;
    140140}
    141 
    142141
    143142/** Callback for polling hub for changes.
    … …  
    193192 * @return basic usb_hub_info_t structure
    194193 */
    195 static usb_hub_info_t * usb_hub_info_create(usb_device_t * usb_dev) {
    196         usb_hub_info_t * result = malloc(sizeof(usb_hub_info_t));
     194static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev) {
     195        usb_hub_info_t * result = malloc(sizeof (usb_hub_info_t));
    197196        if (!result) return NULL;
    198197        result->usb_device = usb_dev;
    … …  
    200199        result->control_pipe = &usb_dev->ctrl_pipe;
    201200        result->is_default_address_used = false;
     201
     202        result->ports = NULL;
     203        result->port_count = (size_t) - 1;
     204        fibril_mutex_initialize(&result->port_mutex);
     205
     206        fibril_mutex_initialize(&result->pending_ops_mutex);
     207        fibril_condvar_initialize(&result->pending_ops_cv);
     208        result->pending_ops_count = 0;
    202209        return result;
    203210}
    … …  
    213220 * @return error code
    214221 */
    215 static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info) {
     222static int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info) {
    216223        // get hub descriptor
    217         usb_log_debug("creating serialized descriptor\n");
     224        usb_log_debug("Creating serialized descriptor\n");
    218225        uint8_t serialized_descriptor[USB_HUB_MAX_DESCRIPTOR_SIZE];
    219226        usb_hub_descriptor_t * descriptor;
    … …  
    227234
    228235        if (opResult != EOK) {
    229                 usb_log_error("failed when receiving hub descriptor, "
    230                     "badcode = %d\n",
    231                     opResult);
     236                usb_log_error("Failed when receiving hub descriptor, "
     237                    "%s\n",
     238                    str_error(opResult));
    232239                free(serialized_descriptor);
    233240                return opResult;
    234241        }
    235         usb_log_debug2("deserializing descriptor\n");
     242        usb_log_debug2("Deserializing descriptor\n");
    236243        descriptor = usb_create_deserialized_hub_desriptor(
    237244            serialized_descriptor);
    … …  
    242249        usb_log_debug("setting port count to %d\n", descriptor->ports_count);
    243250        hub_info->port_count = descriptor->ports_count;
    244         /// \TODO this is not semantically correct
    245251        bool is_power_switched =
    246             ((descriptor->hub_characteristics & 1) ==0);
     252            ((descriptor->hub_characteristics & 1) == 0);
    247253        bool has_individual_port_powering =
    248             ((descriptor->hub_characteristics & 1) !=0);
     254            ((descriptor->hub_characteristics & 1) != 0);
    249255        hub_info->ports = malloc(
    250256            sizeof (usb_hub_port_t) * (hub_info->port_count + 1));
    251         if(!hub_info->ports){
     257        if (!hub_info->ports) {
    252258                return ENOMEM;
    253259        }
    … …  
    256262                usb_hub_port_init(&hub_info->ports[port]);
    257263        }
    258         if(is_power_switched){
    259                 usb_log_debug("is_power_switched\n");
    260                
    261                 if(!has_individual_port_powering){
    262                         usb_log_debug("!has_individual_port_powering\n");
     264        if (is_power_switched) {
     265                usb_log_debug("Hub power switched\n");
     266
     267                if (!has_individual_port_powering) {
     268                        usb_log_debug("Has_global powering\n");
    263269                        opResult = usb_hub_set_feature(hub_info->control_pipe,
    264270                            USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    265271                        if (opResult != EOK) {
    266                                 usb_log_error("cannot power hub: %s\n",
     272                                usb_log_error("Cannot power hub: %s\n",
    267273                                    str_error(opResult));
    268274                        }
    … …  
    270276
    271277                for (port = 1; port <= hub_info->port_count; ++port) {
    272                         usb_log_debug("Powering port %zu.\n",port);
     278                        usb_log_debug("Powering port %zu.\n", port);
    273279                        opResult = usb_hub_set_port_feature(hub_info->control_pipe,
    274280                            port, USB_HUB_FEATURE_PORT_POWER);
    … …  
    278284                        }
    279285                }
    280                
    281         }else{
    282                 usb_log_debug("!is_power_switched, not going to be powered\n");
    283         }
    284         usb_log_debug2("freeing data\n");
     286
     287        } else {
     288                usb_log_debug("Power not switched, not going to be powered\n");
     289        }
     290        usb_log_debug2("Freeing data\n");
    285291        free(descriptor);
    286292        return EOK;
    … …  
    295301 * @return error code
    296302 */
    297 static int usb_hub_set_configuration(usb_hub_info_t * hub_info) {
     303static int usb_hub_set_configuration(usb_hub_info_t *hub_info) {
    298304        //device descriptor
    299305        usb_standard_device_descriptor_t *std_descriptor
    300306            = &hub_info->usb_device->descriptors.device;
    301         usb_log_debug("hub has %d configurations\n",
     307        usb_log_debug("Hub has %d configurations\n",
    302308            std_descriptor->configuration_count);
    303309        if (std_descriptor->configuration_count < 1) {
    304                 usb_log_error("there are no configurations available\n");
     310                usb_log_error("There are no configurations available\n");
    305311                return EINVAL;
    306312        }
    … …  
    320326                return opResult;
    321327        }
    322         usb_log_debug("\tused configuration %d\n",
     328        usb_log_debug("\tUsed configuration %d\n",
    323329            config_descriptor->configuration_number);
    324330
    … …  
    335341 * @return error code
    336342 */
    337 static int usb_hub_start_hub_fibril(usb_hub_info_t * hub_info){
    338         /*
    339          * The processing will require opened control pipe and connection
    340          * to the host controller.
    341          * It is waste of resources but let's hope there will be less
    342          * hubs than the phone limit.
    343          * FIXME: with some proper locking over pipes and session
    344          * auto destruction, this could work better.
    345          */
    346         int rc = usb_hc_connection_open(&hub_info->connection);
    347         if (rc != EOK) {
    348                 //usb_pipe_end_session(hub_info->control_pipe);
    349                 usb_log_error("Failed to open connection to HC: %s.\n",
    350                     str_error(rc));
    351                 return rc;
    352         }
     343static int usb_hub_start_hub_fibril(usb_hub_info_t *hub_info) {
     344        int rc;
    353345
    354346        rc = usb_device_auto_poll(hub_info->usb_device, 0,
    355347            hub_port_changes_callback, ((hub_info->port_count + 1) / 8) + 1,
    356             usb_hub_polling_terminted_callback, hub_info);
     348            usb_hub_polling_terminated_callback, hub_info);
    357349        if (rc != EOK) {
    358350                usb_log_error("Failed to create polling fibril: %s.\n",
    … …  
    373365//*********************************************
    374366
    375 
    376367/**
    377368 * process hub over current change
    … …  
    382373 * @return error code
    383374 */
    384 static int usb_process_hub_over_current(usb_hub_info_t * hub_info,
     375static int usb_process_hub_over_current(usb_hub_info_t *hub_info,
    385376    usb_hub_status_t status) {
    386377        int opResult;
    387         if (usb_hub_is_status(status,USB_HUB_FEATURE_HUB_OVER_CURRENT)){
     378        if (usb_hub_is_status(status, USB_HUB_FEATURE_HUB_OVER_CURRENT)) {
    388379                //poweroff all ports
    389380                unsigned int port;
    390                 for(port = 1;port <= hub_info->port_count;++port){
     381                for (port = 1; port <= hub_info->port_count; ++port) {
    391382                        opResult = usb_hub_clear_port_feature(
    392                             hub_info->control_pipe,port,
     383                            hub_info->control_pipe, port,
    393384                            USB_HUB_FEATURE_PORT_POWER);
    394385                        if (opResult != EOK) {
    395386                                usb_log_warning(
    396                                     "cannot power off port %d;  %d\n",
    397                                     port, opResult);
     387                                    "Cannot power off port %d;  %s\n",
     388                                    port, str_error(opResult));
    398389                        }
    399390                }
    … …  
    401392                //power all ports
    402393                unsigned int port;
    403                 for(port = 1;port <= hub_info->port_count;++port){
     394                for (port = 1; port <= hub_info->port_count; ++port) {
    404395                        opResult = usb_hub_set_port_feature(
    405                             hub_info->control_pipe,port,
     396                            hub_info->control_pipe, port,
    406397                            USB_HUB_FEATURE_PORT_POWER);
    407398                        if (opResult != EOK) {
    408399                                usb_log_warning(
    409                                     "cannot power off port %d;  %d\n",
    410                                     port, opResult);
     400                                    "Cannot power off port %d;  %s\n",
     401                                    port, str_error(opResult));
    411402                        }
    412403                }
    … …  
    423414 * @return error code
    424415 */
    425 static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
     416static int usb_process_hub_local_power_change(usb_hub_info_t *hub_info,
    426417    usb_hub_status_t status) {
    427418        int opResult = EOK;
    428419        opResult = usb_hub_clear_feature(hub_info->control_pipe,
    429420            USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    430                 if (opResult != EOK) {
    431                 usb_log_error("cannnot clear hub power change flag: "
    432                     "%d\n",
    433                     opResult);
     421        if (opResult != EOK) {
     422                usb_log_error("Cannnot clear hub power change flag: "
     423                    "%s\n",
     424                    str_error(opResult));
    434425        }
    435426        return opResult;
    … …  
    443434 * @param hub_info hub instance
    444435 */
    445 static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info) {
    446         usb_log_debug("global interrupt on a hub\n");
     436static void usb_hub_process_global_interrupt(usb_hub_info_t *hub_info) {
     437        usb_log_debug("Global interrupt on a hub\n");
    447438        usb_pipe_t *pipe = hub_info->control_pipe;
    448439        int opResult;
    … …  
    461452            );
    462453        if (opResult != EOK) {
    463                 usb_log_error("could not get hub status\n");
     454                usb_log_error("Could not get hub status: %s\n",
     455                    str_error(opResult));
    464456                return;
    465457        }
    466458        if (rcvd_size != sizeof (usb_port_status_t)) {
    467                 usb_log_error("received status has incorrect size\n");
     459                usb_log_error("Received status has incorrect size\n");
    468460                return;
    469461        }
    470462        //port reset
    471463        if (
    472             usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
     464            usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
    473465                usb_process_hub_over_current(hub_info, status);
    474466        }
    475467        if (
    476             usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
     468            usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
    477469                usb_process_hub_local_power_change(hub_info, status);
    478470        }
    … …  
    487479 * @param data pointer to usb_hub_info_t structure
    488480 */
    489 static void usb_hub_polling_terminted_callback(usb_device_t * device,
    490     bool was_error, void * data){
    491         usb_hub_info_t * hub_info = data;
    492         if(!hub_info) return;
    493         free(hub_info->ports);
    494         free(hub_info);
     481static void usb_hub_polling_terminated_callback(usb_device_t *device,
     482    bool was_error, void *data) {
     483        usb_hub_info_t * hub = data;
     484        assert(hub);
     485
     486        fibril_mutex_lock(&hub->pending_ops_mutex);
     487
     488        /* The device is dead. However there might be some pending operations
     489         * that we need to wait for.
     490         * One of them is device adding in progress.
     491         * The respective fibril is probably waiting for status change
     492         * in port reset (port enable) callback.
     493         * Such change would never come (otherwise we would not be here).
     494         * Thus, we would flush all pending port resets.
     495         */
     496        if (hub->pending_ops_count > 0) {
     497                fibril_mutex_lock(&hub->port_mutex);
     498                size_t port;
     499                for (port = 0; port < hub->port_count; port++) {
     500                        usb_hub_port_t *the_port = hub->ports + port;
     501                        fibril_mutex_lock(&the_port->reset_mutex);
     502                        the_port->reset_completed = true;
     503                        the_port->reset_okay = false;
     504                        fibril_condvar_broadcast(&the_port->reset_cv);
     505                        fibril_mutex_unlock(&the_port->reset_mutex);
     506                }
     507                fibril_mutex_unlock(&hub->port_mutex);
     508        }
     509        /* And now wait for them. */
     510        while (hub->pending_ops_count > 0) {
     511                fibril_condvar_wait(&hub->pending_ops_cv,
     512                    &hub->pending_ops_mutex);
     513        }
     514        fibril_mutex_unlock(&hub->pending_ops_mutex);
     515
     516        usb_device_destroy(hub->usb_device);
     517
     518        free(hub->ports);
     519        free(hub);
    495520}
    496521

  • uspace/drv/usbhub/usbhub.h

    ra5fc431 r399a13c  
    5151#include "ports.h"
    5252
    53 
    54 
    5553/** Information about attached hub. */
    56 struct usb_hub_info_t{
     54struct usb_hub_info_t {
    5755        /** Number of ports. */
    5856        size_t port_count;
    … …  
    6058        /** attached device handles, for each port one */
    6159        usb_hub_port_t *ports;
     60
     61        fibril_mutex_t port_mutex;
    6262
    6363        /** connection to hcd */
    … …  
    8989        /** generic usb device data*/
    9090        usb_device_t * usb_device;
     91
     92        /** Number of pending operations on the mutex to prevent shooting
     93         * ourselves in the foot.
     94         * When the hub is disconnected but we are in the middle of some
     95         * operation, we cannot destroy this structure right away because
     96         * the pending operation might use it.
     97         */
     98        size_t pending_ops_count;
     99        /** Guard for pending_ops_count. */
     100        fibril_mutex_t pending_ops_mutex;
     101        /** Condition variable for pending_ops_count. */
     102        fibril_condvar_t pending_ops_cv;
     103
    91104};
    92105
    93 //int usb_hub_control_loop(void * hub_info_param);
    94 
    95 int usb_hub_add_device(usb_device_t * usb_dev);
     106int usb_hub_add_device(usb_device_t *usb_dev);
    96107
    97108bool hub_port_changes_callback(usb_device_t *dev,

  • uspace/drv/usbhub/usbhub_private.h

    ra5fc431 r399a13c  
    6565 */
    6666static inline void usb_hub_set_descriptor_request(
    67 usb_device_request_setup_packet_t * request
    68 ){
     67    usb_device_request_setup_packet_t * request
     68    ) {
    6969        request->index = 0;
    7070        request->request_type = USB_HUB_REQ_TYPE_GET_DESCRIPTOR;
    … …  
    8787    int port_index,
    8888    usb_hub_class_feature_t feature) {
    89        
     89
    9090        usb_device_request_setup_packet_t clear_request = {
    9191                .request_type = USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE,
    … …  
    9696        clear_request.value = feature;
    9797        return usb_pipe_control_write(pipe, &clear_request,
    98             sizeof(clear_request), NULL, 0);
     98            sizeof (clear_request), NULL, 0);
    9999}
    100100
    … …  
    120120        clear_request.value = feature;
    121121        return usb_pipe_control_write(pipe, &clear_request,
    122             sizeof(clear_request), NULL, 0);
     122            sizeof (clear_request), NULL, 0);
    123123}
    124 
    125124
    126125/**
    … …  
    142141        clear_request.value = feature;
    143142        return usb_pipe_control_write(pipe, &clear_request,
    144             sizeof(clear_request), NULL, 0);
     143            sizeof (clear_request), NULL, 0);
    145144}
    146145
    … …  
    163162        clear_request.value = feature;
    164163        return usb_pipe_control_write(pipe, &clear_request,
    165             sizeof(clear_request), NULL, 0);
     164            sizeof (clear_request), NULL, 0);
    166165}
    167166

  • uspace/drv/usbhub/utils.c

    ra5fc431 r399a13c  
    6262 * @return newly created serializd descriptor pointer
    6363 */
    64 void * usb_create_serialized_hub_descriptor(usb_hub_descriptor_t * descriptor) {
     64void * usb_create_serialized_hub_descriptor(usb_hub_descriptor_t *descriptor) {
    6565        //base size
    6666        size_t size = 7;
    6767        //variable size according to port count
    68         size_t var_size = (descriptor->ports_count+7)/8;
     68        size_t var_size = (descriptor->ports_count + 7) / 8;
    6969        size += 2 * var_size;
    7070        uint8_t * result = malloc(size);
    7171        //size
    72         if(result)
    73                 usb_serialize_hub_descriptor(descriptor,result);
     72        if (result)
     73                usb_serialize_hub_descriptor(descriptor, result);
    7474        return result;
    7575}
    … …  
    8282 * @param serialized_descriptor
    8383 */
    84 void usb_serialize_hub_descriptor(usb_hub_descriptor_t * descriptor,
     84void usb_serialize_hub_descriptor(usb_hub_descriptor_t *descriptor,
    8585    void * serialized_descriptor) {
    8686        //base size
    … …  
    8888        size_t size = 7;
    8989        //variable size according to port count
    90         size_t var_size = (descriptor->ports_count+7)/8;
     90        size_t var_size = (descriptor->ports_count + 7) / 8;
    9191        size += 2 * var_size;
    9292        //size
    … …  
    110110}
    111111
    112 
    113112/**
    114113 * create deserialized desriptor structure out of serialized descriptor
    … …  
    121120 */
    122121usb_hub_descriptor_t * usb_create_deserialized_hub_desriptor(
    123 void * serialized_descriptor) {
     122    void *serialized_descriptor) {
    124123        uint8_t * sdescriptor = serialized_descriptor;
    125124
    … …  
    130129        }
    131130
    132         usb_hub_descriptor_t * result = malloc(sizeof(usb_hub_descriptor_t));
    133         if(result)
    134                 usb_deserialize_hub_desriptor(serialized_descriptor,result);
     131        usb_hub_descriptor_t * result = malloc(sizeof (usb_hub_descriptor_t));
     132        if (result)
     133                usb_deserialize_hub_desriptor(serialized_descriptor, result);
    135134        return result;
    136135}
    … …  
    144143 */
    145144void usb_deserialize_hub_desriptor(
    146 void * serialized_descriptor, usb_hub_descriptor_t * descriptor) {
     145    void * serialized_descriptor, usb_hub_descriptor_t *descriptor) {
    147146        uint8_t * sdescriptor = serialized_descriptor;
    148147        descriptor->ports_count = sdescriptor[2];
    … …  
    151150        descriptor->pwr_on_2_good_time = sdescriptor[5];
    152151        descriptor->current_requirement = sdescriptor[6];
    153         size_t var_size = (descriptor->ports_count+7) / 8;
     152        size_t var_size = (descriptor->ports_count + 7) / 8;
    154153        //descriptor->devices_removable = (uint8_t*) malloc(var_size);
    155154

  • uspace/drv/usbmouse/init.c

    ra5fc431 r399a13c  
    3939#include <usb/hid/hid.h>
    4040#include <usb/dev/request.h>
     41#include <usb/hid/request.h>
    4142#include <errno.h>
    4243
    … …  
    126127       
    127128        /* Set the boot protocol. */
    128         rc = usb_control_request_set(&dev->ctrl_pipe,
    129             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
    130             USB_HIDREQ_SET_PROTOCOL, USB_HID_PROTOCOL_BOOT, dev->interface_no,
    131             NULL, 0);
     129        rc = usbhid_req_set_protocol(&dev->ctrl_pipe, dev->interface_no,
     130            USB_HID_PROTOCOL_BOOT);
    132131        if (rc != EOK) {
    133132                goto leave;

  • uspace/drv/usbmouse/mouse.c

    ra5fc431 r399a13c  
    117117        async_hangup(mouse->console_phone);
    118118        mouse->console_phone = -1;
     119
     120        usb_device_destroy(dev);
    119121}
    120122

  • uspace/lib/drv/generic/driver.c

    ra5fc431 r399a13c  
    405405                                /* The interface has not such method */
    406406                                printf("%s: driver_connection_gen error - "
    407                                     "invalid interface method (%d).\n",
     407                                    "invalid interface method "
     408                                    "(index %" PRIun ").\n",
    408409                                    driver->name, iface_method_idx);
    409410                                async_answer_0(callid, ENOTSUP);

  • uspace/lib/drv/include/usbhc_iface.h

    ra5fc431 r399a13c  
    212212/** USB host controller communication interface. */
    213213typedef struct {
    214         int (*reserve_default_address)(ddf_fun_t *, usb_speed_t);
    215         int (*release_default_address)(ddf_fun_t *);
    216214        int (*request_address)(ddf_fun_t *, usb_speed_t, usb_address_t *);
    217215        int (*bind_address)(ddf_fun_t *, usb_address_t, devman_handle_t);

  • uspace/lib/usbdev/include/usb/dev/driver.h

    ra5fc431 r399a13c  
    168168int usb_device_destroy_pipes(ddf_dev_t *, usb_endpoint_mapping_t *, size_t);
    169169int usb_device_create(ddf_dev_t *, usb_endpoint_description_t **, usb_device_t **, const char **);
     170void usb_device_destroy(usb_device_t *);
    170171
    171172size_t usb_interface_count_alternates(uint8_t *, size_t, uint8_t);

  • uspace/lib/usbdev/src/devdrv.c

    ra5fc431 r399a13c  
    533533}
    534534
     535/** Destroy instance of a USB device.
     536 *
     537 * @param dev Device to be destroyed.
     538 */
     539void usb_device_destroy(usb_device_t *dev)
     540{
     541        if (dev == NULL) {
     542                return;
     543        }
     544
     545        /* Ignore errors and hope for the best. */
     546        usb_device_destroy_pipes(dev->ddf_dev, dev->pipes, dev->pipes_count);
     547        if (dev->descriptors.configuration != NULL) {
     548                free(dev->descriptors.configuration);
     549        }
     550
     551        if (dev->alternate_interfaces != NULL) {
     552                if (dev->alternate_interfaces->alternatives != NULL) {
     553                        free(dev->alternate_interfaces->alternatives);
     554                }
     555                free(dev->alternate_interfaces);
     556        }
     557
     558        free(dev);
     559}
     560
    535561/**
    536562 * @}

  • uspace/lib/usbdev/src/hub.c

    ra5fc431 r399a13c  
    331331                goto leave_release_free_address;
    332332        }
     333       
     334        usb_hc_connection_close(&hc_conn);
    333335
    334336        /*

  • uspace/lib/usbhid/src/hiddescriptor.c

    ra5fc431 r399a13c  
    187187
    188188                field = malloc(sizeof(usb_hid_report_field_t));
     189                if(field == NULL) {
     190                        return ENOMEM;
     191                }
     192
    189193                memset(field, 0, sizeof(usb_hid_report_field_t));
    190194                list_initialize(&field->link);
    … …  
    216220                        }
    217221                        else {
    218                                 usage = report_item->usages[
     222                                usage = report_item->usages[
    219223                                        report_item->usages_count- 1];
    220224                        }
    … …  
    241245
    242246                field->size = report_item->size;
    243                
    244                 size_t offset_byte = (report_item->offset + (i *
    245                         report_item->size)) / 8;
    246 
    247                 size_t offset_bit = 8 - ((report_item->offset + (i *
    248                         report_item->size)) % 8) - report_item->size;
    249 
    250                 field->offset = 8 * offset_byte + offset_bit;
    251                 if(report_item->id != 0) {
     247
     248                if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
     249                        int offset = report_item->offset + report_item->size * i;
     250                        int field_offset = (offset/8)*8 + (offset/8 + 1) * 8 -
     251                                offset - report_item->size;
     252                        if(field_offset < 0) {
     253                                field->offset = 0;
     254                        }
     255                        else {
     256                                field->offset = field_offset;
     257                        }
     258                }
     259                else {
     260                        field->offset = report_item->offset + (i * report_item->size);
     261                }
     262
     263
     264                if(report->use_report_ids != 0) {
    252265                        field->offset += 8;
    253266                        report->use_report_ids = 1;
    254267                }
     268
    255269                field->item_flags = report_item->item_flags;
    256270

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

    ra5fc431 r399a13c  
    153153
    154154
    155         report_des = usb_hid_report_find_description(report, *report_id, type);
     155        report_des = usb_hid_report_find_description(report, *report_id,
     156                type);
     157
    156158        if(report_des == NULL) {
    157159                return EINVAL;
    … …  
    167169                if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
    168170                       
    169                         if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) {
     171                        if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0){
    170172
    171173                                // array
    … …  
    174176               
    175177                                item->usage = USB_HID_EXTENDED_USAGE(
    176                                     item->usages[item->value - item->physical_minimum]);
    177 
    178                                 item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(
    179                                     item->usages[item->value - item->physical_minimum]);
    180 
    181                                 usb_hid_report_set_last_item (item->collection_path,
    182                                     USB_HID_TAG_CLASS_GLOBAL, item->usage_page);
    183 
    184                                 usb_hid_report_set_last_item (item->collection_path,
     178                                    item->usages[
     179                                    item->value - item->physical_minimum]);
     180
     181                                item->usage_page =
     182                                    USB_HID_EXTENDED_USAGE_PAGE(
     183                                    item->usages[
     184                                    item->value - item->physical_minimum]);
     185
     186                                usb_hid_report_set_last_item (
     187                                    item->collection_path,
     188                                    USB_HID_TAG_CLASS_GLOBAL,
     189                                    item->usage_page);
     190
     191                                usb_hid_report_set_last_item (
     192                                    item->collection_path,
    185193                                    USB_HID_TAG_CLASS_LOCAL, item->usage);
    186194                               
    … …  
    188196                        else {
    189197                                // variable item
    190                                 item->value = usb_hid_translate_data(item, data);                               
    191                         }                               
     198                                item->value = usb_hid_translate_data(item,
     199                                    data);                             
     200                        }                       
    192201                }
    193202                list_item = list_item->next;
    … …  
    213222       
    214223        int32_t value=0;
    215         int32_t mask;
    216         const uint8_t *foo;
     224        int32_t mask=0;
     225        const uint8_t *foo=0;
    217226
    218227        // now only shot tags are allowed
    … …  
    240249        if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) {
    241250               
    242                 part_size = ((offset+item->size)%8);
     251                part_size = 0;
    243252
    244253                size_t i=0;
    … …  
    246255                        if(i == (size_t)(offset/8)) {
    247256                                // the higher one
     257                                part_size = 8 - (offset % 8);
    248258                                foo = data + i;
    249259                                mask =  ((1 << (item->size-part_size))-1);
    250                                 value = (*foo & mask) << part_size;
     260                                value = (*foo & mask);
    251261                        }
    252262                        else if(i == ((offset+item->size-1)/8)){
    253263                                // the lower one
    254264                                foo = data + i;
    255                                 mask =  ((1 << part_size)-1) << (8-part_size);
    256                                 value += ((*foo & mask) >> (8-part_size));
     265                                mask = ((1 << (item->size - part_size)) - 1)
     266                                        << (8 - (item->size - part_size));
     267
     268                                value = (((*foo & mask) >> (8 -
     269                                    (item->size - part_size))) << part_size )
     270                                    + value;
    257271                        }
    258272                        else {
    259                                 value = value << 8;
    260                                 value += *(data + 1);
     273                                value = (*(data + 1) << (part_size + 8)) + value;
     274                                part_size += 8;
    261275                        }
    262276                }
    … …  
    375389                report_item = list_get_instance(item, usb_hid_report_field_t, link);
    376390
    377                 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) {
    378                                        
    379                         // array
    380                         value = usb_hid_translate_data_reverse(report_item,
    381                                 report_item->value);
    382 
    383                         offset = report_item->offset;
    384                         length = report_item->size;
    385                 }
    386                 else {
    387                         // variable item
    388                         value  = usb_hid_translate_data_reverse(report_item,
    389                                 report_item->value);
    390 
    391                         offset = report_item->offset;
    392                         length = report_item->size;
    393                 }
    394 
     391                value = usb_hid_translate_data_reverse(report_item,
     392                        report_item->value);
     393
     394                offset = report_des->bit_length - report_item->offset - 1;
     395                length = report_item->size;
     396               
    395397                usb_log_debug("\ttranslated value: %x\n", value);
    396398
    … …  
    617619                        return report_des->report_id;
    618620                }
     621
     622                report_it = report_it->next;
    619623        }
    620624

  • uspace/srv/hid/console/console.c

    ra5fc431 r399a13c  
    5757#include <io/style.h>
    5858#include <io/screenbuffer.h>
     59#include <inttypes.h>
    5960
    6061#include "console.h"
    … …  
    6768/** Interval for checking for new keyboard (1/4s). */
    6869#define HOTPLUG_WATCH_INTERVAL (1000 * 250)
     70
     71/* Kernel defines 32 but does not export it. */
     72#define MAX_IPC_OUTGOING_PHONES 128
     73/** To allow proper phone closing. */
     74static ipc_callid_t driver_phones[MAX_IPC_OUTGOING_PHONES] = { 0 };
    6975
    7076/** Phone to the keyboard driver. */
    … …  
    9096                                       contents and related settings. */
    9197} console_t;
     98
     99
    92100
    93101/** Array of data for virtual consoles */
    … …  
    401409}
    402410
     411static void close_driver_phone(ipc_callid_t hash)
     412{
     413        int i;
     414        for (i = 0; i < MAX_IPC_OUTGOING_PHONES; i++) {
     415                if (driver_phones[i] == hash) {
     416                        printf("Device %" PRIxn " gone.\n", hash);
     417                        driver_phones[i] = 0;
     418                        async_hangup(i);
     419                        return;
     420                }
     421        }
     422}
     423
    403424/** Handler for keyboard */
    404425static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)
    … …  
    415436                case IPC_M_PHONE_HUNGUP:
    416437                        /* TODO: Handle hangup */
     438                        close_driver_phone(iid);
    417439                        return;
    418440                case KBD_EVENT:
    … …  
    458480                case IPC_M_PHONE_HUNGUP:
    459481                        /* TODO: Handle hangup */
     482                        close_driver_phone(iid);
    460483                        return;
    461484                case MEVENT_BUTTON:
    … …  
    715738}
    716739
     740static int async_connect_to_me_hack(int phone, sysarg_t arg1, sysarg_t arg2,
     741sysarg_t arg3, async_client_conn_t client_receiver, ipc_callid_t *hash)
     742{
     743        sysarg_t task_hash;
     744        sysarg_t phone_hash;
     745        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
     746            NULL, NULL, NULL, &task_hash, &phone_hash);
     747        if (rc != EOK)
     748                return rc;
     749
     750        if (client_receiver != NULL)
     751                async_new_connection(task_hash, phone_hash, phone_hash, NULL,
     752                    client_receiver);
     753
     754        if (hash != NULL) {
     755                *hash = phone_hash;
     756        }
     757
     758        return EOK;
     759}
     760
    717761static int connect_keyboard_or_mouse(const char *devname,
    718762    async_client_conn_t handler, const char *path)
    … …  
    729773        }
    730774       
    731         int rc = async_connect_to_me(phone, SERVICE_CONSOLE, 0, 0, handler);
     775        ipc_callid_t hash;
     776        int rc = async_connect_to_me_hack(phone, SERVICE_CONSOLE, 0, phone,
     777            handler, &hash);
    732778        if (rc != EOK) {
    733779                printf(NAME ": " \
    … …  
    737783        }
    738784       
    739         printf(NAME ": found %s \"%s\".\n", devname, path);
     785        driver_phones[phone] = hash;
     786
     787        printf(NAME ": found %s \"%s\" (%" PRIxn ").\n", devname, path, hash);
    740788
    741789        return phone;
Note: See TracChangeset for help on using the changeset viewer.