Changes in / [a43f1d18:97e7e8a] in mainline


Ignore:
Location:
uspace
Files:
2 added
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/root_hub.c

    ra43f1d18 r97e7e8a  
    115115
    116116static const uint32_t hub_set_feature_valid_mask =
    117         (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT) |
    118 (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
     117        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
    119118
    120119
    … …  
    587586        if (!((1 << feature) & hub_set_feature_valid_mask))
    588587                return EINVAL;
    589         if(feature == USB_HUB_FEATURE_C_HUB_LOCAL_POWER)
    590                 feature = USB_HUB_FEATURE_C_HUB_LOCAL_POWER << 16;
    591588        instance->registers->rh_status =
    592589                (instance->registers->rh_status | (1 << feature))

  • uspace/drv/usbhub/Makefile

    ra43f1d18 r97e7e8a  
    3434SOURCES = \
    3535        main.c \
     36        ports.c \
    3637        utils.c \
    37         usbhub.c \
    38         ports.c
     38        usbhub.c
    3939
    4040include $(USPACE_PREFIX)/Makefile.common

  • uspace/drv/usbhub/port_status.h

    ra43f1d18 r97e7e8a  
    4949
    5050/**
    51  * structure holding hub status and changes flags.
    52  * should not be accessed directly, use supplied getter/setter methods.
    53  *
    54  * For more information refer to table 11.16.2.5 in
    55  * "Universal Serial Bus Specification Revision 1.1"
    56  *
    57  */
    58 typedef uint32_t usb_hub_status_t;
    59 
    60 /**
    6151 * set values in request to be it a port status request
    6252 * @param request
    … …  
    6454 */
    6555static inline void usb_hub_set_port_status_request(
    66         usb_device_request_setup_packet_t * request, uint16_t port
    67         ) {
     56usb_device_request_setup_packet_t * request, uint16_t port
     57){
    6858        request->index = port;
    6959        request->request_type = USB_HUB_REQ_TYPE_GET_PORT_STATUS;
    … …  
    7363}
    7464
    75 /**
    76  * set values in request to be it a port status request
    77  * @param request
    78  * @param port
    79  */
    80 static inline void usb_hub_set_hub_status_request(
    81         usb_device_request_setup_packet_t * request
    82         ) {
    83         request->index = 0;
    84         request->request_type = USB_HUB_REQ_TYPE_GET_HUB_STATUS;
    85         request->request = USB_HUB_REQUEST_GET_STATUS;
    86         request->value = 0;
    87         request->length = 4;
    88 }
    8965
    9066/**
    … …  
    9470 */
    9571static inline usb_device_request_setup_packet_t *
    96 usb_hub_create_port_status_request(uint16_t port) {
     72usb_hub_create_port_status_request(uint16_t port){
    9773        usb_device_request_setup_packet_t * result =
    98                 malloc(sizeof(usb_device_request_setup_packet_t));
    99         usb_hub_set_port_status_request(result, port);
     74                usb_new(usb_device_request_setup_packet_t);
     75        usb_hub_set_port_status_request(result,port);
    10076        return result;
    10177}
    10278
     79
    10380/**
    10481 * set the device request to be a port feature enable request
    … …  
    10885 */
    10986static 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         ) {
     87usb_device_request_setup_packet_t * request, uint16_t port,
     88                uint16_t feature_selector
     89){
    11390        request->index = port;
    11491        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    125102 */
    126103static 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         ) {
     104usb_device_request_setup_packet_t * request, uint16_t port,
     105                uint16_t feature_selector
     106){
    130107        request->index = port;
    131108        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    141118 */
    142119static inline void usb_hub_set_enable_port_request(
    143         usb_device_request_setup_packet_t * request, uint16_t port
    144         ) {
     120usb_device_request_setup_packet_t * request, uint16_t port
     121){
    145122        request->index = port;
    146123        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    156133 */
    157134static inline usb_device_request_setup_packet_t *
    158 usb_hub_create_enable_port_request(uint16_t port) {
     135usb_hub_create_enable_port_request(uint16_t port){
    159136        usb_device_request_setup_packet_t * result =
    160                 malloc(sizeof(usb_device_request_setup_packet_t));
    161         usb_hub_set_enable_port_request(result, port);
     137                usb_new(usb_device_request_setup_packet_t);
     138        usb_hub_set_enable_port_request(result,port);
    162139        return result;
    163140}
    … …  
    169146 */
    170147static inline void usb_hub_set_disable_port_request(
    171         usb_device_request_setup_packet_t * request, uint16_t port
    172         ) {
     148usb_device_request_setup_packet_t * request, uint16_t port
     149){
    173150        request->index = port;
    174151        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    184161 */
    185162static inline usb_device_request_setup_packet_t *
    186 usb_hub_create_disable_port_request(uint16_t port) {
     163usb_hub_create_disable_port_request(uint16_t port){
    187164        usb_device_request_setup_packet_t * result =
    188                 malloc(sizeof(usb_device_request_setup_packet_t));
    189         usb_hub_set_disable_port_request(result, port);
     165                usb_new(usb_device_request_setup_packet_t);
     166        usb_hub_set_disable_port_request(result,port);
    190167        return result;
    191168}
    … …  
    197174 */
    198175static inline void usb_hub_set_reset_port_request(
    199         usb_device_request_setup_packet_t * request, uint16_t port
    200         ) {
     176usb_device_request_setup_packet_t * request, uint16_t port
     177){
    201178        request->index = port;
    202179        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    212189 */
    213190static inline usb_device_request_setup_packet_t *
    214 usb_hub_create_reset_port_request(uint16_t port) {
     191usb_hub_create_reset_port_request(uint16_t port){
    215192        usb_device_request_setup_packet_t * result =
    216                 malloc(sizeof(usb_device_request_setup_packet_t));
    217         usb_hub_set_reset_port_request(result, port);
     193                usb_new(usb_device_request_setup_packet_t);
     194        usb_hub_set_reset_port_request(result,port);
    218195        return result;
    219196}
    … …  
    225202 */
    226203static inline void usb_hub_set_power_port_request(
    227         usb_device_request_setup_packet_t * request, uint16_t port
    228         ) {
     204usb_device_request_setup_packet_t * request, uint16_t port
     205){
    229206        request->index = port;
    230207        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    240217 */
    241218static inline void usb_hub_unset_power_port_request(
    242         usb_device_request_setup_packet_t * request, uint16_t port
    243         ) {
     219usb_device_request_setup_packet_t * request, uint16_t port
     220){
    244221        request->index = port;
    245222        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    249226}
    250227
    251 /**
    252  * get i`th bit of port status
    253  *
    254  * @param status
    255  * @param idx
    256  * @return
    257  */
    258 static inline bool usb_port_is_status(usb_port_status_t status, int idx) {
    259         return (status&(1 << idx))!=0;
    260 }
    261 
    262 /**
    263  * set i`th bit of port status
    264  *
    265  * @param status
    266  * @param idx
    267  * @param value
    268  */
    269 static inline void usb_port_status_set_bit(
    270         usb_port_status_t * status, int idx, bool value) {
    271         (*status) = value ?
    272                 ((*status) | (1 << (idx))) :
    273                 ((*status)&(~(1 << (idx))));
    274 }
    275 
    276 /**
    277  * get i`th bit of hub status
    278  *
    279  * @param status
    280  * @param idx
    281  * @return
    282  */
    283 static inline bool usb_hub_is_status(usb_hub_status_t status, int idx) {
    284         return (status&(1 << idx))!=0;
    285 }
    286 
    287 /**
    288  * set i`th bit of hub status
    289  *
    290  * @param status
    291  * @param idx
    292  * @param value
    293  */
    294 static inline void usb_hub_status_set_bit(
    295         usb_hub_status_t * status, int idx, bool value) {
    296         (*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);
     228
     229/** get i`th bit of port status */
     230static inline bool usb_port_get_bit(usb_port_status_t * status, int idx)
     231{
     232        return (((*status)>>(idx))%2);
     233}
     234
     235/** set i`th bit of port status */
     236static inline void usb_port_set_bit(
     237        usb_port_status_t * status, int idx, bool value)
     238{
     239        (*status) = value?
     240                               ((*status)|(1<<(idx))):
     241                               ((*status)&(~(1<<(idx))));
     242}
     243
     244//device connnected on port
     245static inline bool usb_port_dev_connected(usb_port_status_t * status){
     246        return usb_port_get_bit(status,0);
     247}
     248
     249static inline void usb_port_set_dev_connected(usb_port_status_t * status,bool connected){
     250        usb_port_set_bit(status,0,connected);
    321251}
    322252
    323253//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);
     254static inline bool usb_port_enabled(usb_port_status_t * status){
     255        return usb_port_get_bit(status,1);
     256}
     257
     258static inline void usb_port_set_enabled(usb_port_status_t * status,bool enabled){
     259        usb_port_set_bit(status,1,enabled);
    343260}
    344261
    345262//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);
     263static inline bool usb_port_suspended(usb_port_status_t * status){
     264        return usb_port_get_bit(status,2);
     265}
     266
     267static inline void usb_port_set_suspended(usb_port_status_t * status,bool suspended){
     268        usb_port_set_bit(status,2,suspended);
    364269}
    365270
    366271//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);
     272static inline bool usb_port_over_current(usb_port_status_t * status){
     273        return usb_port_get_bit(status,3);
     274}
     275
     276static inline void usb_port_set_over_current(usb_port_status_t * status,bool value){
     277        usb_port_set_bit(status,3,value);
    385278}
    386279
    387280//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);
     281static inline bool usb_port_reset(usb_port_status_t * status){
     282        return usb_port_get_bit(status,4);
     283}
     284
     285static inline void usb_port_set_reset(usb_port_status_t * status,bool value){
     286        usb_port_set_bit(status,4,value);
    406287}
    407288
    408289//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
     290static inline bool usb_port_powered(usb_port_status_t * status){
     291        return usb_port_get_bit(status,8);
     292}
     293
     294static inline void usb_port_set_powered(usb_port_status_t * status,bool powered){
     295        usb_port_set_bit(status,8,powered);
     296}
    430297
    431298//low speed device attached
    432 /**
    433  * low speed device on the port indicator
    434  *
    435  * @param status
    436  * @return true if low speed device is attached
    437  */
    438 static inline bool usb_port_low_speed(usb_port_status_t status) {
    439         return usb_port_is_status(status, 9);
    440 }
    441 
    442 /**
    443  * set low speed device connected bit in port status
    444  *
    445  * @param status
    446  * @param low_speed value of the bit
    447  */
    448 static inline void usb_port_set_low_speed(usb_port_status_t * status, bool low_speed) {
    449         usb_port_status_set_bit(status, 9, low_speed);
    450 }
    451 
    452 //high speed device attached
    453 /**
    454  * high speed device on the port indicator
    455  *
    456  * @param status
    457  * @return true if high speed device is on port
    458  */
    459 static inline bool usb_port_high_speed(usb_port_status_t status) {
    460         return usb_port_is_status(status, 10);
    461 }
    462 
    463 /**
    464  * set high speed device bit in port status
    465  *
    466  * @param status
    467  * @param high_speed value of the bit
    468  */
    469 static inline void usb_port_set_high_speed(usb_port_status_t * status, bool high_speed) {
    470         usb_port_status_set_bit(status, 10, high_speed);
    471 }
    472 
    473 /**
    474  * speed getter for port status
    475  *
    476  * @param status
    477  * @return speed of usb device (for more see usb specification)
    478  */
    479 static inline usb_speed_t usb_port_speed(usb_port_status_t status) {
    480         if (usb_port_low_speed(status))
     299static inline bool usb_port_low_speed(usb_port_status_t * status){
     300        return usb_port_get_bit(status,9);
     301}
     302
     303static inline void usb_port_set_low_speed(usb_port_status_t * status,bool low_speed){
     304        usb_port_set_bit(status,9,low_speed);
     305}
     306
     307//low speed device attached
     308static inline bool usb_port_high_speed(usb_port_status_t * status){
     309        return usb_port_get_bit(status,10);
     310}
     311
     312static inline void usb_port_set_high_speed(usb_port_status_t * status,bool high_speed){
     313        usb_port_set_bit(status,10,high_speed);
     314}
     315
     316static inline usb_speed_t usb_port_speed(usb_port_status_t * status){
     317        if(usb_port_low_speed(status))
    481318                return USB_SPEED_LOW;
    482         if (usb_port_high_speed(status))
     319        if(usb_port_high_speed(status))
    483320                return USB_SPEED_HIGH;
    484321        return USB_SPEED_FULL;
    485322}
    486323
    487 #if 0
     324
    488325//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);
     326static inline bool usb_port_connect_change(usb_port_status_t * status){
     327        return usb_port_get_bit(status,16);
     328}
     329
     330static inline void usb_port_set_connect_change(usb_port_status_t * status,bool change){
     331        usb_port_set_bit(status,16,change);
    506332}
    507333
    508334//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);
     335static inline bool usb_port_enabled_change(usb_port_status_t * status){
     336        return usb_port_get_bit(status,17);
     337}
     338
     339static inline void usb_port_set_enabled_change(usb_port_status_t * status,bool change){
     340        usb_port_set_bit(status,17,change);
    527341}
    528342
    529343//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);
     344static inline bool usb_port_suspend_change(usb_port_status_t * status){
     345        return usb_port_get_bit(status,18);
     346}
     347
     348static inline void usb_port_set_suspend_change(usb_port_status_t * status,bool change){
     349        usb_port_set_bit(status,18,change);
    548350}
    549351
    550352//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);
     353static inline bool usb_port_overcurrent_change(usb_port_status_t * status){
     354        return usb_port_get_bit(status,19);
     355}
     356
     357static inline void usb_port_set_overcurrent_change(usb_port_status_t * status,bool change){
     358        usb_port_set_bit(status,19,change);
    569359}
    570360
    571361//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
     362static inline bool usb_port_reset_completed(usb_port_status_t * status){
     363        return usb_port_get_bit(status,20);
     364}
     365
     366static inline void usb_port_set_reset_completed(usb_port_status_t * status,bool completed){
     367        usb_port_set_bit(status,20,completed);
     368}
     369
    680370
    681371

  • uspace/drv/usbhub/usbhub.c

    ra43f1d18 r97e7e8a  
    3737#include <errno.h>
    3838#include <str_error.h>
    39 #include <inttypes.h>
    4039
    4140#include <usb_iface.h>
    … …  
    5453#include "usb/classes/classes.h"
    5554
    56 
    57 static usb_hub_info_t * usb_hub_info_create(usb_device_t * usb_dev);
    58 
    59 static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info);
    60 
    61 static int usb_hub_set_configuration(usb_hub_info_t * hub_info);
    62 
    63 static int usb_hub_start_hub_fibril(usb_hub_info_t * hub_info);
    64 
    65 static int usb_process_hub_over_current(usb_hub_info_t * hub_info,
    66     usb_hub_status_t status);
    67 
    68 static int usb_process_hub_power_change(usb_hub_info_t * hub_info,
    69     usb_hub_status_t status);
    70 
    71 static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info);
    72 
    73 
    74 /// \TODO malloc checking
     55static int usb_hub_trigger_connecting_non_removable_devices(
     56                usb_hub_info_t * hub, usb_hub_descriptor_t * descriptor);
     57
    7558
    7659//*********************************************
    … …  
    8164
    8265/**
    83  * Initialize hub device driver fibril
    84  *
    85  * Creates hub representation and fibril that periodically checks hub`s status.
    86  * Hub representation is passed to the fibril.
    87  * @param usb_dev generic usb device information
    88  * @return error code
    89  */
    90 int usb_hub_add_device(usb_device_t * usb_dev) {
    91         if (!usb_dev) return EINVAL;
    92         usb_hub_info_t * hub_info = usb_hub_info_create(usb_dev);
    93         //create hc connection
    94         usb_log_debug("Initializing USB wire abstraction.\n");
    95         int opResult = usb_hc_connection_initialize_from_device(
    96             &hub_info->connection,
    97             hub_info->usb_device->ddf_dev);
    98         if (opResult != EOK) {
    99                 usb_log_error("could not initialize connection to device, "
    100                     "errno %d\n",
    101                     opResult);
    102                 free(hub_info);
    103                 return opResult;
    104         }
    105 
    106         usb_pipe_start_session(hub_info->control_pipe);
    107         //set hub configuration
    108         opResult = usb_hub_set_configuration(hub_info);
    109         if (opResult != EOK) {
    110                 usb_log_error("could not set hub configuration, errno %d\n",
    111                     opResult);
    112                 free(hub_info);
    113                 return opResult;
    114         }
    115         //get port count and create attached_devs
    116         opResult = usb_hub_process_hub_specific_info(hub_info);
    117         if (opResult != EOK) {
    118                 usb_log_error("could process hub specific info, errno %d\n",
    119                     opResult);
    120                 free(hub_info);
    121                 return opResult;
    122         }
    123         usb_pipe_end_session(hub_info->control_pipe);
    124 
    125         /// \TODO what is this?
    126         usb_log_debug("Creating `hub' function.\n");
    127         ddf_fun_t *hub_fun = ddf_fun_create(hub_info->usb_device->ddf_dev,
    128             fun_exposed, "hub");
    129         assert(hub_fun != NULL);
    130         hub_fun->ops = NULL;
    131 
    132         opResult = ddf_fun_bind(hub_fun);
    133         assert(opResult == EOK);
    134         opResult = ddf_fun_add_to_class(hub_fun, "hub");
    135         assert(opResult == EOK);
    136 
    137         opResult = usb_hub_start_hub_fibril(hub_info);
    138         if(opResult!=EOK)
    139                 free(hub_info);
    140         return opResult;
    141 }
    142 
    143 
    144 /** Callback for polling hub for changes.
    145  *
    146  * @param dev Device where the change occured.
    147  * @param change_bitmap Bitmap of changed ports.
    148  * @param change_bitmap_size Size of the bitmap in bytes.
    149  * @param arg Custom argument, points to @c usb_hub_info_t.
    150  * @return Whether to continue polling.
    151  */
    152 bool hub_port_changes_callback(usb_device_t *dev,
    153     uint8_t *change_bitmap, size_t change_bitmap_size, void *arg) {
    154         usb_hub_info_t *hub = (usb_hub_info_t *) arg;
    155 
    156         /* FIXME: check that we received enough bytes. */
    157         if (change_bitmap_size == 0) {
    158                 goto leave;
    159         }
    160 
    161         bool change;
    162         change = ((uint8_t*) change_bitmap)[0] & 1;
    163         if (change) {
    164                 usb_hub_process_global_interrupt(hub);
    165         }
    166 
    167         size_t port;
    168         for (port = 1; port < hub->port_count + 1; port++) {
    169                 bool change = (change_bitmap[port / 8] >> (port % 8)) % 2;
    170                 if (change) {
    171                         usb_hub_process_interrupt(hub, port);
    172                 }
    173         }
    174 leave:
    175         /* FIXME: proper interval. */
    176         async_usleep(1000 * 1000 * 10);
    177 
    178         return true;
    179 }
    180 
    181 /**
    182  * release default address used by given hub
    183  *
    184  * Also unsets hub->is_default_address_used. Convenience wrapper function.
    185  * @note hub->connection MUST be open for communication
    186  * @param hub hub representation
    187  * @return error code
    188  */
    189 int usb_hub_release_default_address(usb_hub_info_t * hub) {
    190         int opResult = usb_hc_release_default_address(&hub->connection);
    191         if (opResult != EOK) {
    192                 usb_log_error("could not release default address, errno %d\n",
    193                     opResult);
    194                 return opResult;
    195         }
    196         hub->is_default_address_used = false;
    197         return EOK;
    198 }
    199 
    200 
    201 //*********************************************
    202 //
    203 //  support functions
    204 //
    205 //*********************************************
    206 
    207 /**
    20866 * create usb_hub_info_t structure
    20967 *
    … …  
    21371 */
    21472static usb_hub_info_t * usb_hub_info_create(usb_device_t * usb_dev) {
    215         usb_hub_info_t * result = malloc(sizeof(usb_hub_info_t));
    216         if (!result) return NULL;
     73        usb_hub_info_t * result = usb_new(usb_hub_info_t);
     74        if(!result) return NULL;
    21775        result->usb_device = usb_dev;
    21876        result->status_change_pipe = usb_dev->pipes[0].pipe;
    … …  
    23290 * @return error code
    23391 */
    234 static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info) {
     92static int usb_hub_process_hub_specific_info(usb_hub_info_t * hub_info){
    23593        // get hub descriptor
    23694        usb_log_debug("creating serialized descriptor\n");
    23795        void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE);
    23896        usb_hub_descriptor_t * descriptor;
    239         int opResult;
    240 
     97
     98        /* this was one fix of some bug, should not be needed anymore
     99         * these lines allow to reset hub once more, it can be used as
     100         * brute-force initialization for non-removable devices
     101        int opResult = usb_request_set_configuration(&result->endpoints.control, 1);
     102        if(opResult!=EOK){
     103                usb_log_error("could not set default configuration, errno %d",opResult);
     104                return opResult;
     105        }
     106         */
    241107        size_t received_size;
    242         opResult = usb_request_get_descriptor(hub_info->control_pipe,
    243             USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
    244             USB_DESCTYPE_HUB, 0, 0, serialized_descriptor,
    245             USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
     108        int opResult = usb_request_get_descriptor(&hub_info->usb_device->ctrl_pipe,
     109                        USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
     110                        USB_DESCTYPE_HUB,
     111                        0, 0, serialized_descriptor,
     112                        USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
    246113
    247114        if (opResult != EOK) {
    248                 usb_log_error("failed when receiving hub descriptor, "
    249                     "badcode = %d\n",
    250                     opResult);
     115                usb_log_error("failed when receiving hub descriptor, badcode = %d\n",
     116                                opResult);
    251117                free(serialized_descriptor);
    252118                return opResult;
    … …  
    254120        usb_log_debug2("deserializing descriptor\n");
    255121        descriptor = usb_deserialize_hub_desriptor(serialized_descriptor);
    256         if (descriptor == NULL) {
     122        if(descriptor==NULL){
    257123                usb_log_warning("could not deserialize descriptor \n");
    258124                return opResult;
    259125        }
    260         usb_log_debug("setting port count to %d\n", descriptor->ports_count);
     126        usb_log_debug("setting port count to %d\n",descriptor->ports_count);
    261127        hub_info->port_count = descriptor->ports_count;
    262         /// \TODO this is not semantically correct
    263         hub_info->ports = malloc(
    264             sizeof (usb_hub_port_t) * (hub_info->port_count + 1));
     128        hub_info->ports = malloc(sizeof(usb_hub_port_t) * (hub_info->port_count+1));
    265129        size_t port;
    266130        for (port = 0; port < hub_info->port_count + 1; port++) {
    267131                usb_hub_port_init(&hub_info->ports[port]);
    268132        }
     133        //handle non-removable devices
     134        usb_hub_trigger_connecting_non_removable_devices(hub_info, descriptor);
    269135        usb_log_debug2("freeing data\n");
    270136        free(serialized_descriptor);
    … …  
    273139        return EOK;
    274140}
    275 
    276141/**
    277142 * Set configuration of hub
    … …  
    282147 * @return error code
    283148 */
    284 static int usb_hub_set_configuration(usb_hub_info_t * hub_info) {
     149static int usb_hub_set_configuration(usb_hub_info_t * hub_info){
    285150        //device descriptor
    286151        usb_standard_device_descriptor_t *std_descriptor
    … …  
    288153        usb_log_debug("hub has %d configurations\n",
    289154            std_descriptor->configuration_count);
    290         if (std_descriptor->configuration_count < 1) {
     155        if(std_descriptor->configuration_count<1){
    291156                usb_log_error("there are no configurations available\n");
    292157                return EINVAL;
    … …  
    308173        }
    309174        usb_log_debug("\tused configuration %d\n",
    310             config_descriptor->configuration_number);
     175                        config_descriptor->configuration_number);
    311176
    312177        return EOK;
    … …  
    314179
    315180/**
    316  * create and start fibril with hub control loop
    317  *
    318  * Before the fibril is started, the control pipe and host controller
    319  * connection of the hub is open.
    320  *
    321  * @param hub_info hub representing structure
     181 * Initialize hub device driver fibril
     182 *
     183 * Creates hub representation and fibril that periodically checks hub`s status.
     184 * Hub representation is passed to the fibril.
     185 * @param usb_dev generic usb device information
    322186 * @return error code
    323187 */
    324 static int usb_hub_start_hub_fibril(usb_hub_info_t * hub_info){
     188int usb_hub_add_device(usb_device_t * usb_dev){
     189        if(!usb_dev) return EINVAL;
     190        usb_hub_info_t * hub_info = usb_hub_info_create(usb_dev);
     191        //create hc connection
     192        usb_log_debug("Initializing USB wire abstraction.\n");
     193        int opResult = usb_hc_connection_initialize_from_device(
     194                        &hub_info->connection,
     195                        hub_info->usb_device->ddf_dev);
     196        if(opResult != EOK){
     197                usb_log_error("could not initialize connection to device, errno %d\n",
     198                                opResult);
     199                free(hub_info);
     200                return opResult;
     201        }
     202       
     203        usb_pipe_start_session(hub_info->control_pipe);
     204        //set hub configuration
     205        opResult = usb_hub_set_configuration(hub_info);
     206        if(opResult!=EOK){
     207                usb_log_error("could not set hub configuration, errno %d\n",opResult);
     208                free(hub_info);
     209                return opResult;
     210        }
     211        //get port count and create attached_devs
     212        opResult = usb_hub_process_hub_specific_info(hub_info);
     213        if(opResult!=EOK){
     214                usb_log_error("could not set hub configuration, errno %d\n",opResult);
     215                free(hub_info);
     216                return opResult;
     217        }
     218        usb_pipe_end_session(hub_info->control_pipe);
     219
     220
     221        /// \TODO what is this?
     222        usb_log_debug("Creating `hub' function.\n");
     223        ddf_fun_t *hub_fun = ddf_fun_create(hub_info->usb_device->ddf_dev,
     224                        fun_exposed, "hub");
     225        assert(hub_fun != NULL);
     226        hub_fun->ops = NULL;
     227
     228        int rc = ddf_fun_bind(hub_fun);
     229        assert(rc == EOK);
     230        rc = ddf_fun_add_to_class(hub_fun, "hub");
     231        assert(rc == EOK);
     232
    325233        /*
    326234         * The processing will require opened control pipe and connection
    … …  
    331239         * auto destruction, this could work better.
    332240         */
    333         int rc = usb_pipe_start_session(hub_info->control_pipe);
     241        rc = usb_pipe_start_session(&usb_dev->ctrl_pipe);
    334242        if (rc != EOK) {
    335243                usb_log_error("Failed to start session on control pipe: %s.\n",
    336244                    str_error(rc));
    337                 return rc;
     245                goto leave;
    338246        }
    339247        rc = usb_hc_connection_open(&hub_info->connection);
    340248        if (rc != EOK) {
    341                 usb_pipe_end_session(hub_info->control_pipe);
     249                usb_pipe_end_session(&usb_dev->ctrl_pipe);
    342250                usb_log_error("Failed to open connection to HC: %s.\n",
    343251                    str_error(rc));
    344                 return rc;
     252                goto leave;
    345253        }
    346254
    347255        rc = usb_device_auto_poll(hub_info->usb_device, 0,
    348             hub_port_changes_callback, ((hub_info->port_count + 1) / 8) + 1,
     256            hub_port_changes_callback, ((hub_info->port_count+1) / 8) + 1,
    349257            NULL, hub_info);
    350258        if (rc != EOK) {
    … …  
    358266            hub_info->usb_device->ddf_dev->name, hub_info->port_count);
    359267        return EOK;
    360 }
     268
     269leave:
     270        free(hub_info);
     271
     272        return rc;
     273}
     274
    361275
    362276//*********************************************
    363277//
    364 //  change handling functions
     278//  hub driver code, main loop and port handling
    365279//
    366280//*********************************************
    367281
    368 
    369 /**
    370  * process hub over current change
    371  *
    372  * This means either to power off the hub or power it on.
    373  * @param hub_info hub instance
    374  * @param status hub status bitmask
     282/**
     283 * triggers actions to connect non0removable devices
     284 *
     285 * This will trigger operations leading to activated non-removable device.
     286 * Control pipe of the hub must be open fo communication.
     287 * @param hub hub representation
     288 * @param descriptor usb hub descriptor
    375289 * @return error code
    376290 */
    377 static int usb_process_hub_over_current(usb_hub_info_t * hub_info,
    378     usb_hub_status_t status) {
     291static int usb_hub_trigger_connecting_non_removable_devices(usb_hub_info_t * hub,
     292                usb_hub_descriptor_t * descriptor)
     293{
     294        usb_log_info("attaching non-removable devices(if any)\n");
     295        usb_device_request_setup_packet_t request;
    379296        int opResult;
    380         if (usb_hub_is_status(status,USB_HUB_FEATURE_HUB_OVER_CURRENT)){
    381                 opResult = usb_hub_clear_feature(hub_info->control_pipe,
    382                     USB_HUB_FEATURE_HUB_LOCAL_POWER);
    383                 if (opResult != EOK) {
    384                         usb_log_error("cannot power off hub: %d\n",
    385                             opResult);
    386                 }
    387         } else {
    388                 opResult = usb_hub_set_feature(hub_info->control_pipe,
    389                     USB_HUB_FEATURE_HUB_LOCAL_POWER);
    390                 if (opResult != EOK) {
    391                         usb_log_error("cannot power on hub: %d\n",
    392                             opResult);
    393                 }
    394         }
    395         return opResult;
    396 }
    397 
    398 /**
    399  * process hub power change
    400  *
    401  * If the power has been lost, reestablish it.
    402  * If it was reestablished, re-power all ports.
    403  * @param hub_info hub instance
    404  * @param status hub status bitmask
    405  * @return error code
    406  */
    407 static int usb_process_hub_power_change(usb_hub_info_t * hub_info,
    408     usb_hub_status_t status) {
    409         int opResult;
    410         if (usb_hub_is_status(status,USB_HUB_FEATURE_HUB_LOCAL_POWER)) {
    411                 //restart power on hub
    412                 opResult = usb_hub_set_feature(hub_info->control_pipe,
    413                     USB_HUB_FEATURE_HUB_LOCAL_POWER);
    414                 if (opResult != EOK) {
    415                         usb_log_error("cannot power on hub: %d\n",
    416                             opResult);
    417                 }
    418         } else {//power reestablished on hub- restart ports
    419                 size_t port;
    420                 for (port = 0; port < hub_info->port_count; ++port) {
    421                         opResult = usb_hub_set_port_feature(
    422                             hub_info->control_pipe,
    423                             port, USB_HUB_FEATURE_PORT_POWER);
     297        size_t rcvd_size;
     298        usb_port_status_t status;
     299        uint8_t * non_removable_dev_bitmap = descriptor->devices_removable;
     300        int port;
     301        for(port=1;port<=descriptor->ports_count;++port){
     302                bool is_non_removable =
     303                                ((non_removable_dev_bitmap[port/8]) >> (port%8)) %2;
     304                if(is_non_removable){
     305                        usb_log_debug("non-removable device on port %d\n",port);
     306                        usb_hub_set_port_status_request(&request, port);
     307                        opResult = usb_pipe_control_read(
     308                                        hub->control_pipe,
     309                                        &request, sizeof(usb_device_request_setup_packet_t),
     310                                        &status, 4, &rcvd_size
     311                                        );
    424312                        if (opResult != EOK) {
    425                                 usb_log_error("cannot power on port %d;  %d\n",
    426                                     port, opResult);
     313                                usb_log_error("could not get port status of port %d errno:%d\n",
     314                                                port, opResult);
     315                                return opResult;
     316                        }
     317                        //set the status change bit, so it will be noticed in driver loop
     318                        if(usb_port_dev_connected(&status)){
     319                                usb_hub_set_disable_port_feature_request(&request, port,
     320                                                USB_HUB_FEATURE_PORT_CONNECTION);
     321                                opResult = usb_pipe_control_read(
     322                                                hub->control_pipe,
     323                                                &request, sizeof(usb_device_request_setup_packet_t),
     324                                                &status, 4, &rcvd_size
     325                                                );
     326                                if (opResult != EOK) {
     327                                        usb_log_warning(
     328                                                        "could not clear port connection on port %d errno:%d\n",
     329                                                        port, opResult);
     330                                }
     331                                usb_log_debug("cleared port connection\n");
     332                                usb_hub_set_enable_port_feature_request(&request, port,
     333                                                USB_HUB_FEATURE_PORT_ENABLE);
     334                                opResult = usb_pipe_control_read(
     335                                                hub->control_pipe,
     336                                                &request, sizeof(usb_device_request_setup_packet_t),
     337                                                &status, 4, &rcvd_size
     338                                                );
     339                                if (opResult != EOK) {
     340                                        usb_log_warning(
     341                                                        "could not set port enabled on port %d errno:%d\n",
     342                                                        port, opResult);
     343                                }
     344                                usb_log_debug("port set to enabled - should lead to connection change\n");
    427345                        }
    428346                }
    429347        }
    430         return opResult;
    431 }
    432 
    433 /**
    434  * process hub interrupts
    435  *
    436  * The change can be either in the over-current condition or
    437  * local-power lost condition.
    438  * @param hub_info hub instance
    439  */
    440 static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info) {
    441         usb_log_debug("global interrupt on a hub\n");
    442         usb_pipe_t *pipe = hub_info->control_pipe;
     348        /// \TODO this is just a debug code
     349        for(port=1;port<=descriptor->ports_count;++port){
     350                bool is_non_removable =
     351                                ((non_removable_dev_bitmap[port/8]) >> (port%8)) %2;
     352                if(is_non_removable){
     353                        usb_log_debug("port %d is non-removable\n",port);
     354                        usb_port_status_t status;
     355                        size_t rcvd_size;
     356                        usb_device_request_setup_packet_t request;
     357                        //int opResult;
     358                        usb_hub_set_port_status_request(&request, port);
     359                        //endpoint 0
     360                        opResult = usb_pipe_control_read(
     361                                        hub->control_pipe,
     362                                        &request, sizeof(usb_device_request_setup_packet_t),
     363                                        &status, 4, &rcvd_size
     364                                        );
     365                        if (opResult != EOK) {
     366                                usb_log_error("could not get port status %d\n",opResult);
     367                        }
     368                        if (rcvd_size != sizeof (usb_port_status_t)) {
     369                                usb_log_error("received status has incorrect size\n");
     370                        }
     371                        //something connected/disconnected
     372                        if (usb_port_connect_change(&status)) {
     373                                usb_log_debug("some connection changed\n");
     374                        }
     375                        usb_log_debug("status: %s\n",usb_debug_str_buffer(
     376                                        (uint8_t *)&status,4,4));
     377                }
     378        }
     379        return EOK;
     380}
     381
     382
     383/**
     384 * release default address used by given hub
     385 *
     386 * Also unsets hub->is_default_address_used. Convenience wrapper function.
     387 * @note hub->connection MUST be open for communication
     388 * @param hub hub representation
     389 * @return error code
     390 */
     391static int usb_hub_release_default_address(usb_hub_info_t * hub){
     392        int opResult = usb_hc_release_default_address(&hub->connection);
     393        if(opResult!=EOK){
     394                usb_log_error("could not release default address, errno %d\n",opResult);
     395                return opResult;
     396        }
     397        hub->is_default_address_used = false;
     398        return EOK;
     399}
     400
     401/**
     402 * routine called when a device on port has been removed
     403 *
     404 * If the device on port had default address, it releases default address.
     405 * Otherwise does not do anything, because DDF does not allow to remove device
     406 * from it`s device tree.
     407 * @param hub hub representation
     408 * @param port port number, starting from 1
     409 */
     410void usb_hub_removed_device(
     411    usb_hub_info_t * hub,uint16_t port) {
     412
     413        int opResult = usb_hub_clear_port_feature(hub->control_pipe,
     414                                port, USB_HUB_FEATURE_C_PORT_CONNECTION);
     415        if(opResult != EOK){
     416                usb_log_warning("could not clear port-change-connection flag\n");
     417        }
     418        /** \TODO remove device from device manager - not yet implemented in
     419         * devide manager
     420         */
     421       
     422        //close address
     423        if(hub->ports[port].attached_device.address >= 0){
     424                /*uncomment this code to use it when DDF allows device removal
     425                opResult = usb_hc_unregister_device(
     426                                &hub->connection, hub->attached_devs[port].address);
     427                if(opResult != EOK) {
     428                        dprintf(USB_LOG_LEVEL_WARNING, "could not release address of " \
     429                            "removed device: %d", opResult);
     430                }
     431                hub->attached_devs[port].address = 0;
     432                hub->attached_devs[port].handle = 0;
     433                 */
     434        }else{
     435                usb_log_warning("this is strange, disconnected device had no address\n");
     436                //device was disconnected before it`s port was reset - return default address
     437                usb_hub_release_default_address(hub);
     438        }
     439}
     440
     441
     442/**
     443 * Process over current condition on port.
     444 *
     445 * Turn off the power on the port.
     446 *
     447 * @param hub hub representation
     448 * @param port port number, starting from 1
     449 */
     450void usb_hub_over_current( usb_hub_info_t * hub,
     451                uint16_t port){
    443452        int opResult;
    444 
    445         usb_port_status_t status;
    446         size_t rcvd_size;
    447         usb_device_request_setup_packet_t request;
    448         //int opResult;
    449         usb_hub_set_hub_status_request(&request);
    450         //endpoint 0
    451 
    452         opResult = usb_pipe_control_read(
    453             pipe,
    454             &request, sizeof (usb_device_request_setup_packet_t),
    455             &status, 4, &rcvd_size
    456             );
    457         if (opResult != EOK) {
    458                 usb_log_error("could not get hub status\n");
    459                 return;
    460         }
    461         if (rcvd_size != sizeof (usb_port_status_t)) {
    462                 usb_log_error("received status has incorrect size\n");
    463                 return;
    464         }
    465         //port reset
    466         if (
    467             usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
    468                 usb_process_hub_over_current(hub_info, status);
    469         }
    470         if (
    471             usb_hub_is_status(status,16+USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
    472                 usb_process_hub_power_change(hub_info, status);
    473         }
    474 }
     453        opResult = usb_hub_clear_port_feature(hub->control_pipe,
     454            port, USB_HUB_FEATURE_PORT_POWER);
     455        if(opResult!=EOK){
     456                usb_log_error("cannot power off port %d;  %d\n",
     457                                port, opResult);
     458        }
     459}
     460
    475461
    476462/**

  • uspace/drv/usbhub/usbhub.h

    ra43f1d18 r97e7e8a  
    3737
    3838#include <ipc/devman.h>
     39#include <usb/usb.h>
    3940#include <ddf/driver.h>
    4041
     42#define NAME "usbhub"
     43
    4144#include <usb/hub.h>
    42 #include <usb/classes/hub.h>
    4345
    4446#include <usb/pipes.h>
    4547#include <usb/devdrv.h>
    46 
    47 #include <fibril_synch.h>
    48 
    49 #define NAME "usbhub"
    5048
    5149#include "ports.h"
    … …  
    5452
    5553/** Information about attached hub. */
    56 typedef struct usb_hub_info_t{
     54typedef struct {
    5755        /** Number of ports. */
    5856        size_t port_count;
    5957
    60         /** attached device handles, for each port one */
     58        /** Ports. */
    6159        usb_hub_port_t *ports;
    62 
     60       
    6361        /** connection to hcd */
    6462        usb_hc_connection_t connection;
    … …  
    9189} usb_hub_info_t;
    9290
    93 //int usb_hub_control_loop(void * hub_info_param);
     91/**
     92 * function running the hub-controlling loop.
     93 * @param hub_info_param hub info pointer
     94 */
     95int usb_hub_control_loop(void * hub_info_param);
     96
     97/**
     98 * Check changes on specified hub
     99 * @param hub_info_param pointer to usb_hub_info_t structure
     100 * @return error code if there is problem when initializing communication with
     101 * hub, EOK otherwise
     102 */
     103int usb_hub_check_hub_changes(usb_hub_info_t * hub_info_param);
     104
     105void usb_hub_removed_device(usb_hub_info_t *, uint16_t);
     106void usb_hub_over_current(usb_hub_info_t *, uint16_t);
    94107
    95108int usb_hub_add_device(usb_device_t * usb_dev);
    96 
    97 bool hub_port_changes_callback(usb_device_t *dev,
    98     uint8_t *change_bitmap, size_t change_bitmap_size, void *arg);
    99 
    100 int usb_hub_release_default_address(usb_hub_info_t * hub);
    101109
    102110#endif

  • uspace/drv/usbhub/usbhub_private.h

    ra43f1d18 r97e7e8a  
    5454//
    5555//************
     56#define usb_new(type) (type*)malloc(sizeof(type))
    5657
    5758
     59/**
     60 * Create hub structure instance
     61 *
     62 * Set the address and port count information most importantly.
     63 *
     64 * @param device
     65 * @param hc host controller phone
     66 * @return
     67 */
    5868usb_hub_info_t * usb_create_hub_info(ddf_dev_t * device);
    5969
    … …  
    100110
    101111/**
    102  * Clear feature on hub port.
    103  *
    104  * @param hc Host controller telephone
    105  * @param address Hub address
    106  * @param port_index Port
    107  * @param feature Feature selector
    108  * @return Operation result
    109  */
    110 static inline int usb_hub_set_port_feature(usb_pipe_t *pipe,
    111     int port_index,
    112     usb_hub_class_feature_t feature) {
    113 
    114         usb_device_request_setup_packet_t clear_request = {
    115                 .request_type = USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE,
    116                 .request = USB_DEVREQ_SET_FEATURE,
    117                 .length = 0,
    118                 .index = port_index
    119         };
    120         clear_request.value = feature;
    121         return usb_pipe_control_write(pipe, &clear_request,
    122             sizeof(clear_request), NULL, 0);
    123 }
    124 
    125 
    126 /**
    127  * Clear feature on hub port.
    128  *
    129  * @param pipe pipe to hub control endpoint
    130  * @param feature Feature selector
    131  * @return Operation result
    132  */
    133 static inline int usb_hub_clear_feature(usb_pipe_t *pipe,
    134     usb_hub_class_feature_t feature) {
    135 
    136         usb_device_request_setup_packet_t clear_request = {
    137                 .request_type = USB_HUB_REQ_TYPE_CLEAR_HUB_FEATURE,
    138                 .request = USB_DEVREQ_CLEAR_FEATURE,
    139                 .length = 0,
    140                 .index = 0
    141         };
    142         clear_request.value = feature;
    143         return usb_pipe_control_write(pipe, &clear_request,
    144             sizeof(clear_request), NULL, 0);
    145 }
    146 
    147 /**
    148  * Clear feature on hub port.
    149  *
    150  * @param pipe pipe to hub control endpoint
    151  * @param feature Feature selector
    152  * @return Operation result
    153  */
    154 static inline int usb_hub_set_feature(usb_pipe_t *pipe,
    155     usb_hub_class_feature_t feature) {
    156 
    157         usb_device_request_setup_packet_t clear_request = {
    158                 .request_type = USB_HUB_REQ_TYPE_CLEAR_HUB_FEATURE,
    159                 .request = USB_DEVREQ_SET_FEATURE,
    160                 .length = 0,
    161                 .index = 0
    162         };
    163         clear_request.value = feature;
    164         return usb_pipe_control_write(pipe, &clear_request,
    165             sizeof(clear_request), NULL, 0);
    166 }
    167 
    168 /**
    169112 * create uint8_t array with serialized descriptor
    170113 *

  • uspace/drv/usbhub/utils.c

    ra43f1d18 r97e7e8a  
    6060        size_t size = 7;
    6161        //variable size according to port count
    62         size_t var_size = (descriptor->ports_count+7)/8;
     62        size_t var_size = descriptor->ports_count / 8 + ((descriptor->ports_count % 8 > 0) ? 1 : 0);
    6363        size += 2 * var_size;
    64         uint8_t * result = malloc(size);
     64        uint8_t * result = (uint8_t*) malloc(size);
    6565        //size
    6666        result[0] = size;
    … …  
    8484}
    8585
    86 usb_hub_descriptor_t * usb_deserialize_hub_desriptor(
    87 void * serialized_descriptor) {
    88         uint8_t * sdescriptor = serialized_descriptor;
     86usb_hub_descriptor_t * usb_deserialize_hub_desriptor(void * serialized_descriptor) {
     87        uint8_t * sdescriptor = (uint8_t*) serialized_descriptor;
    8988
    9089        if (sdescriptor[1] != USB_DESCTYPE_HUB) {
    91                 usb_log_warning("trying to deserialize wrong descriptor %x\n",
    92                     sdescriptor[1]);
     90                usb_log_warning("trying to deserialize wrong descriptor %x\n",sdescriptor[1]);
    9391                return NULL;
    9492        }
    9593
    96         usb_hub_descriptor_t * result = malloc(sizeof(usb_hub_descriptor_t));
     94        usb_hub_descriptor_t * result = usb_new(usb_hub_descriptor_t);
    9795       
    9896
    … …  
    102100        result->pwr_on_2_good_time = sdescriptor[5];
    103101        result->current_requirement = sdescriptor[6];
    104         size_t var_size = (result->ports_count+7) / 8;
     102        size_t var_size = result->ports_count / 8 + ((result->ports_count % 8 > 0)
     103                        ? 1 : 0);
    105104        result->devices_removable = (uint8_t*) malloc(var_size);
    106105

  • uspace/lib/usb/include/usb/classes/hub.h

    ra43f1d18 r97e7e8a  
    4343 */
    4444typedef enum {
    45         USB_HUB_FEATURE_HUB_LOCAL_POWER = 0,
    46         USB_HUB_FEATURE_HUB_OVER_CURRENT = 1,
    4745        USB_HUB_FEATURE_C_HUB_LOCAL_POWER = 0,
    4846        USB_HUB_FEATURE_C_HUB_OVER_CURRENT = 1,
    … …  
    6159        /* USB_HUB_FEATURE_ = , */
    6260} usb_hub_class_feature_t;
    63 
    6461
    6562/** Header of standard hub descriptor without the "variadic" part. */
Note: See TracChangeset for help on using the changeset viewer.