Changes in / [399a13c:a5fc431] in mainline


Ignore:
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

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

  • uspace/drv/ohci/root_hub.c

    r399a13c ra5fc431  
    5757        .device_version = 0,
    5858        .length = sizeof (usb_standard_device_descriptor_t),
     59        /// \TODO this value is guessed
    5960        .max_packet_size = 8,
    6061        .vendor_id = 0x16db,
    … …  
    116117 */
    117118static const uint32_t hub_clear_feature_by_writing_one_mask =
    118     RHS_CLEAR_PORT_POWER;
     119   RHS_CLEAR_PORT_POWER;
    119120
    120121/**
    … …  
    411412        request->transfered_size = 4;
    412413        uint32_t data = instance->registers->rh_port_status[port - 1];
    413         memcpy(request->data_buffer, &data, 4);
     414        memcpy(request->data_buffer,&data,4);
    414415#if 0
    415416        int i;
    … …  
    444445        uint32_t data = mask & instance->registers->rh_status;
    445446        //uint32_buffer[0] = mask & instance->registers->rh_status;
    446         memcpy(request->data_buffer, &data, 4);
     447        memcpy(request->data_buffer,&data,4);
    447448
    448449        return EOK;
    … …  
    467468
    468469        usb_hub_bm_request_type_t request_type = request_packet->request_type;
    469         if (buffer_size < 4) {
     470        if (buffer_size < 4/*request_packet->length*/) {///\TODO
    470471                usb_log_warning("requested more data than buffer size\n");
    471472                return EINVAL;
    … …  
    498499            | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
    499500        bzero(bitmap, instance->interrupt_mask_size);
    500         if ((instance->registers->rh_status & mask) != 0) {
     501        if ((instance->registers->rh_status & mask) !=0 ) {
    501502                bitmap[0] = 1;
    502503        }
    … …  
    677678            (instance->registers->rh_port_status[port - 1] | (1 << feature))
    678679            & (~port_clear_feature_valid_mask);
     680        /// \TODO any error?
     681
    679682        return EOK;
    680683}
    … …  
    704707            & (~port_clear_feature_valid_mask))
    705708            | (1 << feature);
     709        /// \TODO any error?
    706710
    707711        return EOK;
    … …  
    921925 * @return
    922926 */
    923 static int process_interrupt_mask_in_instance(rh_t *instance,
    924     usb_transfer_batch_t * request) {
     927static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request) {
    925928        memcpy(request->data_buffer, instance->interrupt_buffer,
    926929            instance->interrupt_mask_size);
    … …  
    942945 * @return
    943946 */
    944 static bool is_zeros(void *buffer, size_t size) {
     947static bool is_zeros(void * buffer, size_t size) {
    945948        if (!buffer) return true;
    946949        if (!size) return true;

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

    r399a13c ra5fc431  
    5555
    5656/** UHCI port structure */
    57 typedef struct uhci_port {
     57typedef struct uhci_port
     58{
    5859        const char *id_string;
    5960        port_status_t *address;
    … …  
    6768
    6869int uhci_port_init(
    69     uhci_port_t *port, port_status_t *address, unsigned number,
    70     unsigned usec, ddf_dev_t *rh);
     70  uhci_port_t *port, port_status_t *address, unsigned number,
     71  unsigned usec, ddf_dev_t *rh);
    7172
    7273void uhci_port_fini(uhci_port_t *port);

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

    r399a13c ra5fc431  
    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 (%zu).\n",
     101        usb_log_debug2("hid_dev: %p, Max input report size (%d).\n",
    102102            hid_dev, hid_dev->max_input_report_size);
    103103       
    … …  
    226226        }
    227227       
    228         usb_log_debug("HID function created. Handle: %" PRIun "\n", fun->handle);
     228        usb_log_debug("HID function created. Handle: %d\n", fun->handle);
    229229       
    230230        return EOK;

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

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

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

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

  • uspace/drv/usbhub/main.c

    r399a13c ra5fc431  
    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

    r399a13c ra5fc431  
    6464 */
    6565static inline void usb_hub_set_port_status_request(
    66     usb_device_request_setup_packet_t *request, uint16_t port) {
     66        usb_device_request_setup_packet_t * request, uint16_t port
     67        ) {
    6768        request->index = port;
    6869        request->request_type = USB_HUB_REQ_TYPE_GET_PORT_STATUS;
    … …  
    7879 */
    7980static inline void usb_hub_set_hub_status_request(
    80     usb_device_request_setup_packet_t *request) {
     81        usb_device_request_setup_packet_t * request
     82        ) {
    8183        request->index = 0;
    8284        request->request_type = USB_HUB_REQ_TYPE_GET_HUB_STATUS;
    … …  
    9395static inline usb_device_request_setup_packet_t *
    9496usb_hub_create_port_status_request(uint16_t port) {
    95         usb_device_request_setup_packet_t *result =
    96             malloc(sizeof (usb_device_request_setup_packet_t));
     97        usb_device_request_setup_packet_t * result =
     98                malloc(sizeof(usb_device_request_setup_packet_t));
    9799        usb_hub_set_port_status_request(result, port);
    98100        return result;
    … …  
    106108 */
    107109static inline void usb_hub_set_enable_port_feature_request(
    108     usb_device_request_setup_packet_t *request, uint16_t port,
    109     uint16_t feature_selector) {
     110        usb_device_request_setup_packet_t * request, uint16_t port,
     111        uint16_t feature_selector
     112        ) {
    110113        request->index = port;
    111114        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    122125 */
    123126static inline void usb_hub_set_disable_port_feature_request(
    124     usb_device_request_setup_packet_t *request, uint16_t port,
    125     uint16_t feature_selector
    126     ) {
     127        usb_device_request_setup_packet_t * request, uint16_t port,
     128        uint16_t feature_selector
     129        ) {
    127130        request->index = port;
    128131        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    138141 */
    139142static inline void usb_hub_set_enable_port_request(
    140     usb_device_request_setup_packet_t *request, uint16_t port
    141     ) {
     143        usb_device_request_setup_packet_t * request, uint16_t port
     144        ) {
    142145        request->index = port;
    143146        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    154157static inline usb_device_request_setup_packet_t *
    155158usb_hub_create_enable_port_request(uint16_t port) {
    156         usb_device_request_setup_packet_t *result =
    157             malloc(sizeof (usb_device_request_setup_packet_t));
     159        usb_device_request_setup_packet_t * result =
     160                malloc(sizeof(usb_device_request_setup_packet_t));
    158161        usb_hub_set_enable_port_request(result, port);
    159162        return result;
    … …  
    166169 */
    167170static inline void usb_hub_set_disable_port_request(
    168     usb_device_request_setup_packet_t *request, uint16_t port
    169     ) {
     171        usb_device_request_setup_packet_t * request, uint16_t port
     172        ) {
    170173        request->index = port;
    171174        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    182185static inline usb_device_request_setup_packet_t *
    183186usb_hub_create_disable_port_request(uint16_t port) {
    184         usb_device_request_setup_packet_t *result =
    185             malloc(sizeof (usb_device_request_setup_packet_t));
     187        usb_device_request_setup_packet_t * result =
     188                malloc(sizeof(usb_device_request_setup_packet_t));
    186189        usb_hub_set_disable_port_request(result, port);
    187190        return result;
    … …  
    194197 */
    195198static inline void usb_hub_set_reset_port_request(
    196     usb_device_request_setup_packet_t *request, uint16_t port
    197     ) {
     199        usb_device_request_setup_packet_t * request, uint16_t port
     200        ) {
    198201        request->index = port;
    199202        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    210213static inline usb_device_request_setup_packet_t *
    211214usb_hub_create_reset_port_request(uint16_t port) {
    212         usb_device_request_setup_packet_t *result =
    213             malloc(sizeof (usb_device_request_setup_packet_t));
     215        usb_device_request_setup_packet_t * result =
     216                malloc(sizeof(usb_device_request_setup_packet_t));
    214217        usb_hub_set_reset_port_request(result, port);
    215218        return result;
    … …  
    222225 */
    223226static inline void usb_hub_set_power_port_request(
    224     usb_device_request_setup_packet_t *request, uint16_t port
    225     ) {
     227        usb_device_request_setup_packet_t * request, uint16_t port
     228        ) {
    226229        request->index = port;
    227230        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    237240 */
    238241static inline void usb_hub_unset_power_port_request(
    239     usb_device_request_setup_packet_t *request, uint16_t port
    240     ) {
     242        usb_device_request_setup_packet_t * request, uint16_t port
     243        ) {
    241244        request->index = port;
    242245        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    254257 */
    255258static inline bool usb_port_is_status(usb_port_status_t status, int idx) {
    256         return (status & (1 << idx)) != 0;
     259        return (status&(1 << idx))!=0;
    257260}
    258261
    … …  
    265268 */
    266269static inline void usb_port_status_set_bit(
    267     usb_port_status_t * status, int idx, bool value) {
     270        usb_port_status_t * status, int idx, bool value) {
    268271        (*status) = value ?
    269             ((*status) | (1 << (idx))) :
    270             ((*status)&(~(1 << (idx))));
     272                ((*status) | (1 << (idx))) :
     273                ((*status)&(~(1 << (idx))));
    271274}
    272275
    … …  
    279282 */
    280283static inline bool usb_hub_is_status(usb_hub_status_t status, int idx) {
    281         return (status & (1 << idx)) != 0;
     284        return (status&(1 << idx))!=0;
    282285}
    283286
    … …  
    290293 */
    291294static inline void usb_hub_status_set_bit(
    292     usb_hub_status_t *status, int idx, bool value) {
     295        usb_hub_status_t * status, int idx, bool value) {
    293296        (*status) = value ?
    294             ((*status) | (1 << (idx))) :
    295             ((*status)&(~(1 << (idx))));
    296 }
    297 
     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 */
     309static 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 */
     319static 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 */
     331static 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 */
     341static 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 */
     352static 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 */
     362static 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 */
     373static 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 */
     383static 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 */
     394static 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 */
     404static 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 */
     415static 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 */
     425static 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
    298432/**
    299433 * low speed device on the port indicator
    … …  
    312446 * @param low_speed value of the bit
    313447 */
    314 static inline void usb_port_set_low_speed(usb_port_status_t *status, bool low_speed) {
     448static inline void usb_port_set_low_speed(usb_port_status_t * status, bool low_speed) {
    315449        usb_port_status_set_bit(status, 9, low_speed);
    316450}
    317451
    318452//high speed device attached
    319 
    320453/**
    321454 * high speed device on the port indicator
    … …  
    334467 * @param high_speed value of the bit
    335468 */
    336 static inline void usb_port_set_high_speed(usb_port_status_t *status, bool high_speed) {
     469static inline void usb_port_set_high_speed(usb_port_status_t * status, bool high_speed) {
    337470        usb_port_status_set_bit(status, 10, high_speed);
    338471}
    … …  
    352485}
    353486
     487#if 0
     488//connect change
     489/**
     490 * port connect change indicator
     491 *
     492 * @param status
     493 * @return true if connection has changed
     494 */
     495static 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 */
     504static 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 */
     515static 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 */
     525static 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 */
     536static 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 */
     546static 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 */
     557static 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 */
     567static 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 */
     577static 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 */
     587static 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 */
     598static 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 */
     608static 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 */
     620static 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 */
     630static 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 */
     643static 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 */
     653static 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 */
     665static 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 */
     675static 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
    354680
    355681

  • uspace/drv/usbhub/ports.c

    r399a13c ra5fc431  
    4747#include "port_status.h"
    4848
     49
    4950/** Information for fibril for device discovery. */
    5051struct add_device_phase1 {
    … …  
    6465 * any function here and must be cleared by hand
    6566 */
    66 static const int non_handled_changes[] = {
     67static const int non_handled_changes[] =  {
    6768        USB_HUB_FEATURE_C_PORT_ENABLE,
    6869        USB_HUB_FEATURE_C_PORT_SUSPEND
    … …  
    7071
    7172static void usb_hub_removed_device(
    72     usb_hub_info_t *hub, uint16_t port);
    73 
    74 static void usb_hub_port_reset_completed(usb_hub_info_t *hub,
    75     uint16_t port, uint32_t status);
    76 
    77 static void usb_hub_port_over_current(usb_hub_info_t *hub,
    78     uint16_t port, uint32_t status);
     73        usb_hub_info_t * hub, uint16_t port);
     74
     75static void usb_hub_port_reset_completed(usb_hub_info_t * hub,
     76        uint16_t port, uint32_t status);
     77
     78static void usb_hub_port_over_current(usb_hub_info_t * hub,
     79        uint16_t port, uint32_t status);
    7980
    8081static int get_port_status(usb_pipe_t *ctrl_pipe, size_t port,
    … …  
    9596 * @param port port number, starting from 1
    9697 */
    97 void 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);
     98void 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);
    100101        //determine type of change
    101102        //usb_pipe_t *pipe = hub->control_pipe;
    … …  
    133134        if (usb_port_is_status(status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT)) {
    134135                //check if it was not auto-resolved
    135                 usb_log_debug("Overcurrent change on port\n");
     136                usb_log_debug("overcurrent change on port\n");
    136137                usb_hub_port_over_current(hub, port, status);
    137138        }
    … …  
    140141                usb_hub_port_reset_completed(hub, port, status);
    141142        }
    142         usb_log_debug("Status x%x : %d\n ", status, status);
     143        usb_log_debug("status x%x : %d\n ", status, status);
    143144
    144145        usb_port_status_set_bit(
    145             &status, USB_HUB_FEATURE_C_PORT_CONNECTION, false);
     146            &status, USB_HUB_FEATURE_C_PORT_CONNECTION,false);
    146147        usb_port_status_set_bit(
    147             &status, USB_HUB_FEATURE_C_PORT_RESET, false);
     148            &status, USB_HUB_FEATURE_C_PORT_RESET,false);
    148149        usb_port_status_set_bit(
    149             &status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT, false);
    150 
     150            &status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT,false);
     151       
    151152        //clearing not yet handled changes     
    152153        unsigned int feature_idx;
    153         for (feature_idx = 0;
    154             feature_idx < non_handled_changes_count;
    155             ++feature_idx) {
     154        for(feature_idx = 0;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: %s\n",
    168                                     bit_idx, str_error(opResult)
     167                                    "could not clear port flag %d: %d\n",
     168                                    bit_idx, 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
    180181
    181182/**
    … …  
    189190 */
    190191static void usb_hub_removed_device(
    191     usb_hub_info_t *hub, uint16_t port) {
     192        usb_hub_info_t * hub, uint16_t port) {
    192193
    193194        int opResult = usb_hub_clear_port_feature(hub->control_pipe,
    194             port, USB_HUB_FEATURE_C_PORT_CONNECTION);
     195                port, USB_HUB_FEATURE_C_PORT_CONNECTION);
    195196        if (opResult != EOK) {
    196                 usb_log_warning("Could not clear port-change-connection flag\n");
     197                usb_log_warning("could not clear port-change-connection flag\n");
    197198        }
    198199        /** \TODO remove device from device manager - not yet implemented in
    … …  
    201202
    202203        //close address
    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;
     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                 */
    214217        } else {
    215218                usb_log_warning("Device removed before being registered.\n");
    … …  
    220223                 * port reset callback from new device wrapper.
    221224                 */
     225                usb_hub_port_t *the_port = hub->ports + port;
    222226                fibril_mutex_lock(&the_port->reset_mutex);
    223227                the_port->reset_completed = true;
    … …  
    226230                fibril_mutex_unlock(&the_port->reset_mutex);
    227231        }
    228 
    229         fibril_mutex_unlock(&hub->port_mutex);
    230 }
     232}
     233
    231234
    232235/**
    … …  
    239242 * @param status
    240243 */
    241 static void usb_hub_port_reset_completed(usb_hub_info_t *hub,
    242     uint16_t port, uint32_t status) {
     244static void usb_hub_port_reset_completed(usb_hub_info_t * hub,
     245        uint16_t port, uint32_t status){
    243246        usb_log_debug("Port %zu reset complete.\n", (size_t) port);
    244247        if (usb_port_is_status(status, USB_HUB_FEATURE_PORT_ENABLE)) {
    … …  
    272275 * @param port port number, starting from 1
    273276 */
    274 static void usb_hub_port_over_current(usb_hub_info_t *hub,
    275     uint16_t port, uint32_t status) {
     277static void usb_hub_port_over_current(usb_hub_info_t * hub,
     278        uint16_t port, uint32_t status) {
    276279        int opResult;
    277         if (usb_port_is_status(status, USB_HUB_FEATURE_PORT_OVER_CURRENT)) {
     280        if(usb_port_is_status(status, USB_HUB_FEATURE_PORT_OVER_CURRENT)){
    278281                opResult = usb_hub_clear_port_feature(hub->control_pipe,
    279                     port, USB_HUB_FEATURE_PORT_POWER);
     282                        port, USB_HUB_FEATURE_PORT_POWER);
    280283                if (opResult != EOK) {
    281                         usb_log_error("Cannot power off port %d; %s\n",
    282                             port, str_error(opResult));
     284                        usb_log_error("cannot power off port %d;  %d\n",
     285                                port, opResult);
    283286                }
    284         } else {
     287        }else{
    285288                opResult = usb_hub_set_port_feature(hub->control_pipe,
    286                     port, USB_HUB_FEATURE_PORT_POWER);
     289                        port, USB_HUB_FEATURE_PORT_POWER);
    287290                if (opResult != EOK) {
    288                         usb_log_error("Cannot power on port %d; %s\n",
    289                             port, str_error(opResult));
     291                        usb_log_error("cannot power on port %d;  %d\n",
     292                                port, opResult);
    290293                }
    291294        }
    … …  
    300303 */
    301304static int get_port_status(usb_pipe_t *ctrl_pipe, size_t port,
    302     usb_port_status_t *status) {
     305    usb_port_status_t *status)
     306{
    303307        size_t recv_size;
    304308        usb_device_request_setup_packet_t request;
    … …  
    307311        usb_hub_set_port_status_request(&request, port);
    308312        int rc = usb_pipe_control_read(ctrl_pipe,
    309             &request, sizeof (usb_device_request_setup_packet_t),
    310             &status_tmp, sizeof (status_tmp), &recv_size);
     313            &request, sizeof(usb_device_request_setup_packet_t),
     314            &status_tmp, sizeof(status_tmp), &recv_size);
    311315        if (rc != EOK) {
    312316                return rc;
    … …  
    333337 * @return Error code.
    334338 */
    335 static int enable_port_callback(int port_no, void *arg) {
     339static int enable_port_callback(int port_no, void *arg)
     340{
    336341        usb_hub_info_t *hub = arg;
    337342        int rc;
    … …  
    341346        usb_hub_set_reset_port_request(&request, port_no);
    342347        rc = usb_pipe_control_write(hub->control_pipe,
    343             &request, sizeof (request), NULL, 0);
     348            &request, sizeof(request), NULL, 0);
    344349        if (rc != EOK) {
    345350                usb_log_warning("Port reset failed: %s.\n", str_error(rc));
    … …  
    371376 * @return 0 Always.
    372377 */
    373 static int add_device_phase1_worker_fibril(void *arg) {
     378static int add_device_phase1_worker_fibril(void *arg)
     379{
    374380        struct add_device_phase1 *data
    375381            = (struct add_device_phase1 *) arg;
    … …  
    390396        }
    391397
    392         fibril_mutex_lock(&data->hub->port_mutex);
    393398        data->hub->ports[data->port].attached_device.handle = child_handle;
    394399        data->hub->ports[data->port].attached_device.address = new_address;
    395         fibril_mutex_unlock(&data->hub->port_mutex);
    396400
    397401        usb_log_info("Detected new device on `%s' (port %zu), "
    … …  
    403407        free(arg);
    404408
    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 
    412409        return EOK;
    413410}
     411
    414412
    415413/** Start device adding when connection change is detected.
    … …  
    423421 */
    424422static int create_add_device_fibril(usb_hub_info_t *hub, size_t port,
    425     usb_speed_t speed) {
     423    usb_speed_t speed)
     424{
    426425        struct add_device_phase1 *data
    427             = malloc(sizeof (struct add_device_phase1));
     426            = malloc(sizeof(struct add_device_phase1));
    428427        if (data == NULL) {
    429428                return ENOMEM;
    … …  
    453452                return ENOMEM;
    454453        }
    455         fibril_mutex_lock(&hub->pending_ops_mutex);
    456         hub->pending_ops_count++;
    457         fibril_mutex_unlock(&hub->pending_ops_mutex);
    458454        fibril_add_ready(fibril);
    459455

  • uspace/drv/usbhub/ports.h

    r399a13c ra5fc431  
    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

    r399a13c ra5fc431  
    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_terminated_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_terminted_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                     " %s\n",
    103                     str_error(opResult));
     101                usb_log_error("could not initialize connection to device, "
     102                    "errno %d\n",
     103                    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, %s\n",
    112                     str_error(opResult));
     111                usb_log_error("could not set hub configuration, errno %d\n",
     112                    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, %s\n",
    120                     str_error(opResult));
     119                usb_log_error("could process hub specific info, errno %d\n",
     120                    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
    141142
    142143/** Callback for polling hub for changes.
    … …  
    192193 * @return basic usb_hub_info_t structure
    193194 */
    194 static 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));
     195static 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));
    196197        if (!result) return NULL;
    197198        result->usb_device = usb_dev;
    … …  
    199200        result->control_pipe = &usb_dev->ctrl_pipe;
    200201        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;
    209202        return result;
    210203}
    … …  
    220213 * @return error code
    221214 */
    222 static int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info) {
     215static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info) {
    223216        // get hub descriptor
    224         usb_log_debug("Creating serialized descriptor\n");
     217        usb_log_debug("creating serialized descriptor\n");
    225218        uint8_t serialized_descriptor[USB_HUB_MAX_DESCRIPTOR_SIZE];
    226219        usb_hub_descriptor_t * descriptor;
    … …  
    234227
    235228        if (opResult != EOK) {
    236                 usb_log_error("Failed when receiving hub descriptor, "
    237                     "%s\n",
    238                     str_error(opResult));
     229                usb_log_error("failed when receiving hub descriptor, "
     230                    "badcode = %d\n",
     231                    opResult);
    239232                free(serialized_descriptor);
    240233                return opResult;
    241234        }
    242         usb_log_debug2("Deserializing descriptor\n");
     235        usb_log_debug2("deserializing descriptor\n");
    243236        descriptor = usb_create_deserialized_hub_desriptor(
    244237            serialized_descriptor);
    … …  
    249242        usb_log_debug("setting port count to %d\n", descriptor->ports_count);
    250243        hub_info->port_count = descriptor->ports_count;
     244        /// \TODO this is not semantically correct
    251245        bool is_power_switched =
    252             ((descriptor->hub_characteristics & 1) == 0);
     246            ((descriptor->hub_characteristics & 1) ==0);
    253247        bool has_individual_port_powering =
    254             ((descriptor->hub_characteristics & 1) != 0);
     248            ((descriptor->hub_characteristics & 1) !=0);
    255249        hub_info->ports = malloc(
    256250            sizeof (usb_hub_port_t) * (hub_info->port_count + 1));
    257         if (!hub_info->ports) {
     251        if(!hub_info->ports){
    258252                return ENOMEM;
    259253        }
    … …  
    262256                usb_hub_port_init(&hub_info->ports[port]);
    263257        }
    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");
     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");
    269263                        opResult = usb_hub_set_feature(hub_info->control_pipe,
    270264                            USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    271265                        if (opResult != EOK) {
    272                                 usb_log_error("Cannot power hub: %s\n",
     266                                usb_log_error("cannot power hub: %s\n",
    273267                                    str_error(opResult));
    274268                        }
    … …  
    276270
    277271                for (port = 1; port <= hub_info->port_count; ++port) {
    278                         usb_log_debug("Powering port %zu.\n", port);
     272                        usb_log_debug("Powering port %zu.\n",port);
    279273                        opResult = usb_hub_set_port_feature(hub_info->control_pipe,
    280274                            port, USB_HUB_FEATURE_PORT_POWER);
    … …  
    284278                        }
    285279                }
    286 
    287         } else {
    288                 usb_log_debug("Power not switched, not going to be powered\n");
    289         }
    290         usb_log_debug2("Freeing data\n");
     280               
     281        }else{
     282                usb_log_debug("!is_power_switched, not going to be powered\n");
     283        }
     284        usb_log_debug2("freeing data\n");
    291285        free(descriptor);
    292286        return EOK;
    … …  
    301295 * @return error code
    302296 */
    303 static int usb_hub_set_configuration(usb_hub_info_t *hub_info) {
     297static int usb_hub_set_configuration(usb_hub_info_t * hub_info) {
    304298        //device descriptor
    305299        usb_standard_device_descriptor_t *std_descriptor
    306300            = &hub_info->usb_device->descriptors.device;
    307         usb_log_debug("Hub has %d configurations\n",
     301        usb_log_debug("hub has %d configurations\n",
    308302            std_descriptor->configuration_count);
    309303        if (std_descriptor->configuration_count < 1) {
    310                 usb_log_error("There are no configurations available\n");
     304                usb_log_error("there are no configurations available\n");
    311305                return EINVAL;
    312306        }
    … …  
    326320                return opResult;
    327321        }
    328         usb_log_debug("\tUsed configuration %d\n",
     322        usb_log_debug("\tused configuration %d\n",
    329323            config_descriptor->configuration_number);
    330324
    … …  
    341335 * @return error code
    342336 */
    343 static int usb_hub_start_hub_fibril(usb_hub_info_t *hub_info) {
    344         int rc;
     337static 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        }
    345353
    346354        rc = usb_device_auto_poll(hub_info->usb_device, 0,
    347355            hub_port_changes_callback, ((hub_info->port_count + 1) / 8) + 1,
    348             usb_hub_polling_terminated_callback, hub_info);
     356            usb_hub_polling_terminted_callback, hub_info);
    349357        if (rc != EOK) {
    350358                usb_log_error("Failed to create polling fibril: %s.\n",
    … …  
    365373//*********************************************
    366374
     375
    367376/**
    368377 * process hub over current change
    … …  
    373382 * @return error code
    374383 */
    375 static int usb_process_hub_over_current(usb_hub_info_t *hub_info,
     384static int usb_process_hub_over_current(usb_hub_info_t * hub_info,
    376385    usb_hub_status_t status) {
    377386        int opResult;
    378         if (usb_hub_is_status(status, USB_HUB_FEATURE_HUB_OVER_CURRENT)) {
     387        if (usb_hub_is_status(status,USB_HUB_FEATURE_HUB_OVER_CURRENT)){
    379388                //poweroff all ports
    380389                unsigned int port;
    381                 for (port = 1; port <= hub_info->port_count; ++port) {
     390                for(port = 1;port <= hub_info->port_count;++port){
    382391                        opResult = usb_hub_clear_port_feature(
    383                             hub_info->control_pipe, port,
     392                            hub_info->control_pipe,port,
    384393                            USB_HUB_FEATURE_PORT_POWER);
    385394                        if (opResult != EOK) {
    386395                                usb_log_warning(
    387                                     "Cannot power off port %d;  %s\n",
    388                                     port, str_error(opResult));
     396                                    "cannot power off port %d;  %d\n",
     397                                    port, opResult);
    389398                        }
    390399                }
    … …  
    392401                //power all ports
    393402                unsigned int port;
    394                 for (port = 1; port <= hub_info->port_count; ++port) {
     403                for(port = 1;port <= hub_info->port_count;++port){
    395404                        opResult = usb_hub_set_port_feature(
    396                             hub_info->control_pipe, port,
     405                            hub_info->control_pipe,port,
    397406                            USB_HUB_FEATURE_PORT_POWER);
    398407                        if (opResult != EOK) {
    399408                                usb_log_warning(
    400                                     "Cannot power off port %d;  %s\n",
    401                                     port, str_error(opResult));
     409                                    "cannot power off port %d;  %d\n",
     410                                    port, opResult);
    402411                        }
    403412                }
    … …  
    414423 * @return error code
    415424 */
    416 static int usb_process_hub_local_power_change(usb_hub_info_t *hub_info,
     425static int usb_process_hub_local_power_change(usb_hub_info_t * hub_info,
    417426    usb_hub_status_t status) {
    418427        int opResult = EOK;
    419428        opResult = usb_hub_clear_feature(hub_info->control_pipe,
    420429            USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    421         if (opResult != EOK) {
    422                 usb_log_error("Cannnot clear hub power change flag: "
    423                     "%s\n",
    424                     str_error(opResult));
     430                if (opResult != EOK) {
     431                usb_log_error("cannnot clear hub power change flag: "
     432                    "%d\n",
     433                    opResult);
    425434        }
    426435        return opResult;
    … …  
    434443 * @param hub_info hub instance
    435444 */
    436 static void usb_hub_process_global_interrupt(usb_hub_info_t *hub_info) {
    437         usb_log_debug("Global interrupt on a hub\n");
     445static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info) {
     446        usb_log_debug("global interrupt on a hub\n");
    438447        usb_pipe_t *pipe = hub_info->control_pipe;
    439448        int opResult;
    … …  
    452461            );
    453462        if (opResult != EOK) {
    454                 usb_log_error("Could not get hub status: %s\n",
    455                     str_error(opResult));
     463                usb_log_error("could not get hub status\n");
    456464                return;
    457465        }
    458466        if (rcvd_size != sizeof (usb_port_status_t)) {
    459                 usb_log_error("Received status has incorrect size\n");
     467                usb_log_error("received status has incorrect size\n");
    460468                return;
    461469        }
    462470        //port reset
    463471        if (
    464             usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
     472            usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
    465473                usb_process_hub_over_current(hub_info, status);
    466474        }
    467475        if (
    468             usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
     476            usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
    469477                usb_process_hub_local_power_change(hub_info, status);
    470478        }
    … …  
    479487 * @param data pointer to usb_hub_info_t structure
    480488 */
    481 static 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);
     489static 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);
    520495}
    521496

  • uspace/drv/usbhub/usbhub.h

    r399a13c ra5fc431  
    5151#include "ports.h"
    5252
     53
     54
    5355/** Information about attached hub. */
    54 struct usb_hub_info_t {
     56struct usb_hub_info_t{
    5557        /** Number of ports. */
    5658        size_t port_count;
    … …  
    5860        /** attached device handles, for each port one */
    5961        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 
    10491};
    10592
    106 int usb_hub_add_device(usb_device_t *usb_dev);
     93//int usb_hub_control_loop(void * hub_info_param);
     94
     95int usb_hub_add_device(usb_device_t * usb_dev);
    10796
    10897bool hub_port_changes_callback(usb_device_t *dev,

  • uspace/drv/usbhub/usbhub_private.h

    r399a13c ra5fc431  
    6565 */
    6666static inline void usb_hub_set_descriptor_request(
    67     usb_device_request_setup_packet_t * request
    68     ) {
     67usb_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
    124125
    125126/**
    … …  
    141142        clear_request.value = feature;
    142143        return usb_pipe_control_write(pipe, &clear_request,
    143             sizeof (clear_request), NULL, 0);
     144            sizeof(clear_request), NULL, 0);
    144145}
    145146
    … …  
    162163        clear_request.value = feature;
    163164        return usb_pipe_control_write(pipe, &clear_request,
    164             sizeof (clear_request), NULL, 0);
     165            sizeof(clear_request), NULL, 0);
    165166}
    166167

  • uspace/drv/usbhub/utils.c

    r399a13c ra5fc431  
    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
    112113/**
    113114 * create deserialized desriptor structure out of serialized descriptor
    … …  
    120121 */
    121122usb_hub_descriptor_t * usb_create_deserialized_hub_desriptor(
    122     void *serialized_descriptor) {
     123void * serialized_descriptor) {
    123124        uint8_t * sdescriptor = serialized_descriptor;
    124125
    … …  
    129130        }
    130131
    131         usb_hub_descriptor_t * result = malloc(sizeof (usb_hub_descriptor_t));
    132         if (result)
    133                 usb_deserialize_hub_desriptor(serialized_descriptor, result);
     132        usb_hub_descriptor_t * result = malloc(sizeof(usb_hub_descriptor_t));
     133        if(result)
     134                usb_deserialize_hub_desriptor(serialized_descriptor,result);
    134135        return result;
    135136}
    … …  
    143144 */
    144145void usb_deserialize_hub_desriptor(
    145     void * serialized_descriptor, usb_hub_descriptor_t *descriptor) {
     146void * serialized_descriptor, usb_hub_descriptor_t * descriptor) {
    146147        uint8_t * sdescriptor = serialized_descriptor;
    147148        descriptor->ports_count = sdescriptor[2];
    … …  
    150151        descriptor->pwr_on_2_good_time = sdescriptor[5];
    151152        descriptor->current_requirement = sdescriptor[6];
    152         size_t var_size = (descriptor->ports_count + 7) / 8;
     153        size_t var_size = (descriptor->ports_count+7) / 8;
    153154        //descriptor->devices_removable = (uint8_t*) malloc(var_size);
    154155

  • uspace/drv/usbmouse/init.c

    r399a13c ra5fc431  
    3939#include <usb/hid/hid.h>
    4040#include <usb/dev/request.h>
    41 #include <usb/hid/request.h>
    4241#include <errno.h>
    4342
    … …  
    127126       
    128127        /* Set the boot protocol. */
    129         rc = usbhid_req_set_protocol(&dev->ctrl_pipe, dev->interface_no,
    130             USB_HID_PROTOCOL_BOOT);
     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);
    131132        if (rc != EOK) {
    132133                goto leave;

  • uspace/drv/usbmouse/mouse.c

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

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

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

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

    r399a13c ra5fc431  
    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 *);
    214216        int (*request_address)(ddf_fun_t *, usb_speed_t, usb_address_t *);
    215217        int (*bind_address)(ddf_fun_t *, usb_address_t, devman_handle_t);

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

    r399a13c ra5fc431  
    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 **);
    170 void usb_device_destroy(usb_device_t *);
    171170
    172171size_t usb_interface_count_alternates(uint8_t *, size_t, uint8_t);

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

    r399a13c ra5fc431  
    533533}
    534534
    535 /** Destroy instance of a USB device.
    536  *
    537  * @param dev Device to be destroyed.
    538  */
    539 void 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 
    561535/**
    562536 * @}

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

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

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

    r399a13c ra5fc431  
    187187
    188188                field = malloc(sizeof(usb_hid_report_field_t));
    189                 if(field == NULL) {
    190                         return ENOMEM;
    191                 }
    192 
    193189                memset(field, 0, sizeof(usb_hid_report_field_t));
    194190                list_initialize(&field->link);
    … …  
    220216                        }
    221217                        else {
    222                                 usage = report_item->usages[
     218                                usage = report_item->usages[
    223219                                        report_item->usages_count- 1];
    224220                        }
    … …  
    245241
    246242                field->size = report_item->size;
    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) {
     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) {
    265252                        field->offset += 8;
    266253                        report->use_report_ids = 1;
    267254                }
    268 
    269255                field->item_flags = report_item->item_flags;
    270256

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

    r399a13c ra5fc431  
    153153
    154154
    155         report_des = usb_hid_report_find_description(report, *report_id,
    156                 type);
    157 
     155        report_des = usb_hid_report_find_description(report, *report_id, type);
    158156        if(report_des == NULL) {
    159157                return EINVAL;
    … …  
    169167                if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) {
    170168                       
    171                         if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0){
     169                        if(USB_HID_ITEM_FLAG_VARIABLE(item->item_flags) == 0) {
    172170
    173171                                // array
    … …  
    176174               
    177175                                item->usage = USB_HID_EXTENDED_USAGE(
    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,
     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,
    193185                                    USB_HID_TAG_CLASS_LOCAL, item->usage);
    194186                               
    … …  
    196188                        else {
    197189                                // variable item
    198                                 item->value = usb_hid_translate_data(item,
    199                                     data);                             
    200                         }                       
     190                                item->value = usb_hid_translate_data(item, data);                               
     191                        }                               
    201192                }
    202193                list_item = list_item->next;
    … …  
    222213       
    223214        int32_t value=0;
    224         int32_t mask=0;
    225         const uint8_t *foo=0;
     215        int32_t mask;
     216        const uint8_t *foo;
    226217
    227218        // now only shot tags are allowed
    … …  
    249240        if((size_t)(offset/8) != (size_t)((offset+item->size-1)/8)) {
    250241               
    251                 part_size = 0;
     242                part_size = ((offset+item->size)%8);
    252243
    253244                size_t i=0;
    … …  
    255246                        if(i == (size_t)(offset/8)) {
    256247                                // the higher one
    257                                 part_size = 8 - (offset % 8);
    258248                                foo = data + i;
    259249                                mask =  ((1 << (item->size-part_size))-1);
    260                                 value = (*foo & mask);
     250                                value = (*foo & mask) << part_size;
    261251                        }
    262252                        else if(i == ((offset+item->size-1)/8)){
    263253                                // the lower one
    264254                                foo = data + i;
    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;
     255                                mask =  ((1 << part_size)-1) << (8-part_size);
     256                                value += ((*foo & mask) >> (8-part_size));
    271257                        }
    272258                        else {
    273                                 value = (*(data + 1) << (part_size + 8)) + value;
    274                                 part_size += 8;
     259                                value = value << 8;
     260                                value += *(data + 1);
    275261                        }
    276262                }
    … …  
    389375                report_item = list_get_instance(item, usb_hid_report_field_t, link);
    390376
    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                
     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
    397395                usb_log_debug("\ttranslated value: %x\n", value);
    398396
    … …  
    619617                        return report_des->report_id;
    620618                }
    621 
    622                 report_it = report_it->next;
    623619        }
    624620

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

    r399a13c ra5fc431  
    5757#include <io/style.h>
    5858#include <io/screenbuffer.h>
    59 #include <inttypes.h>
    6059
    6160#include "console.h"
    … …  
    6867/** Interval for checking for new keyboard (1/4s). */
    6968#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. */
    74 static ipc_callid_t driver_phones[MAX_IPC_OUTGOING_PHONES] = { 0 };
    7569
    7670/** Phone to the keyboard driver. */
    … …  
    9690                                       contents and related settings. */
    9791} console_t;
    98 
    99 
    10092
    10193/** Array of data for virtual consoles */
    … …  
    409401}
    410402
    411 static 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 
    424403/** Handler for keyboard */
    425404static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)
    … …  
    436415                case IPC_M_PHONE_HUNGUP:
    437416                        /* TODO: Handle hangup */
    438                         close_driver_phone(iid);
    439417                        return;
    440418                case KBD_EVENT:
    … …  
    480458                case IPC_M_PHONE_HUNGUP:
    481459                        /* TODO: Handle hangup */
    482                         close_driver_phone(iid);
    483460                        return;
    484461                case MEVENT_BUTTON:
    … …  
    738715}
    739716
    740 static int async_connect_to_me_hack(int phone, sysarg_t arg1, sysarg_t arg2,
    741 sysarg_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 
    761717static int connect_keyboard_or_mouse(const char *devname,
    762718    async_client_conn_t handler, const char *path)
    … …  
    773729        }
    774730       
    775         ipc_callid_t hash;
    776         int rc = async_connect_to_me_hack(phone, SERVICE_CONSOLE, 0, phone,
    777             handler, &hash);
     731        int rc = async_connect_to_me(phone, SERVICE_CONSOLE, 0, 0, handler);
    778732        if (rc != EOK) {
    779733                printf(NAME ": " \
    … …  
    783737        }
    784738       
    785         driver_phones[phone] = hash;
    786 
    787         printf(NAME ": found %s \"%s\" (%" PRIxn ").\n", devname, path, hash);
     739        printf(NAME ": found %s \"%s\".\n", devname, path);
    788740
    789741        return phone;
Note: See TracChangeset for help on using the changeset viewer.