Changeset 3dba1ca in mainline


Ignore:
Timestamp:
2011-04-05T20:12:26Z (13 years ago)
Author:
Matus Dekanek <smekideki@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a209648
Parents:
90d0522
Message:

some more comments

Location:
uspace/drv/usbhub
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/usbhub/port_status.h

    r90d0522 r3dba1ca  
    6464 */
    6565static inline void usb_hub_set_port_status_request(
    66 usb_device_request_setup_packet_t * request, uint16_t port
    67 ){
     66        usb_device_request_setup_packet_t * request, uint16_t port
     67        ) {
    6868        request->index = port;
    6969        request->request_type = USB_HUB_REQ_TYPE_GET_PORT_STATUS;
    … …  
    7979 */
    8080static inline void usb_hub_set_hub_status_request(
    81 usb_device_request_setup_packet_t * request
    82 ){
     81        usb_device_request_setup_packet_t * request
     82        ) {
    8383        request->index = 0;
    8484        request->request_type = USB_HUB_REQ_TYPE_GET_HUB_STATUS;
    … …  
    8888}
    8989
    90 
    9190/**
    9291 * create request for usb hub port status
    … …  
    9594 */
    9695static inline usb_device_request_setup_packet_t *
    97 usb_hub_create_port_status_request(uint16_t port){
     96usb_hub_create_port_status_request(uint16_t port) {
    9897        usb_device_request_setup_packet_t * result =
    9998                usb_new(usb_device_request_setup_packet_t);
    100         usb_hub_set_port_status_request(result,port);
     99        usb_hub_set_port_status_request(result, port);
    101100        return result;
    102101}
    103102
    104 
    105103/**
    106104 * set the device request to be a port feature enable request
    … …  
    110108 */
    111109static inline void usb_hub_set_enable_port_feature_request(
    112 usb_device_request_setup_packet_t * request, uint16_t port,
    113                 uint16_t feature_selector
    114 ){
     110        usb_device_request_setup_packet_t * request, uint16_t port,
     111        uint16_t feature_selector
     112        ) {
    115113        request->index = port;
    116114        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    127125 */
    128126static inline void usb_hub_set_disable_port_feature_request(
    129 usb_device_request_setup_packet_t * request, uint16_t port,
    130                 uint16_t feature_selector
    131 ){
     127        usb_device_request_setup_packet_t * request, uint16_t port,
     128        uint16_t feature_selector
     129        ) {
    132130        request->index = port;
    133131        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    143141 */
    144142static inline void usb_hub_set_enable_port_request(
    145 usb_device_request_setup_packet_t * request, uint16_t port
    146 ){
     143        usb_device_request_setup_packet_t * request, uint16_t port
     144        ) {
    147145        request->index = port;
    148146        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    158156 */
    159157static inline usb_device_request_setup_packet_t *
    160 usb_hub_create_enable_port_request(uint16_t port){
     158usb_hub_create_enable_port_request(uint16_t port) {
    161159        usb_device_request_setup_packet_t * result =
    162160                usb_new(usb_device_request_setup_packet_t);
    163         usb_hub_set_enable_port_request(result,port);
     161        usb_hub_set_enable_port_request(result, port);
    164162        return result;
    165163}
    … …  
    171169 */
    172170static inline void usb_hub_set_disable_port_request(
    173 usb_device_request_setup_packet_t * request, uint16_t port
    174 ){
     171        usb_device_request_setup_packet_t * request, uint16_t port
     172        ) {
    175173        request->index = port;
    176174        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    186184 */
    187185static inline usb_device_request_setup_packet_t *
    188 usb_hub_create_disable_port_request(uint16_t port){
     186usb_hub_create_disable_port_request(uint16_t port) {
    189187        usb_device_request_setup_packet_t * result =
    190188                usb_new(usb_device_request_setup_packet_t);
    191         usb_hub_set_disable_port_request(result,port);
     189        usb_hub_set_disable_port_request(result, port);
    192190        return result;
    193191}
    … …  
    199197 */
    200198static inline void usb_hub_set_reset_port_request(
    201 usb_device_request_setup_packet_t * request, uint16_t port
    202 ){
     199        usb_device_request_setup_packet_t * request, uint16_t port
     200        ) {
    203201        request->index = port;
    204202        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    214212 */
    215213static inline usb_device_request_setup_packet_t *
    216 usb_hub_create_reset_port_request(uint16_t port){
     214usb_hub_create_reset_port_request(uint16_t port) {
    217215        usb_device_request_setup_packet_t * result =
    218216                usb_new(usb_device_request_setup_packet_t);
    219         usb_hub_set_reset_port_request(result,port);
     217        usb_hub_set_reset_port_request(result, port);
    220218        return result;
    221219}
    … …  
    227225 */
    228226static inline void usb_hub_set_power_port_request(
    229 usb_device_request_setup_packet_t * request, uint16_t port
    230 ){
     227        usb_device_request_setup_packet_t * request, uint16_t port
     228        ) {
    231229        request->index = port;
    232230        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    242240 */
    243241static inline void usb_hub_unset_power_port_request(
    244 usb_device_request_setup_packet_t * request, uint16_t port
    245 ){
     242        usb_device_request_setup_packet_t * request, uint16_t port
     243        ) {
    246244        request->index = port;
    247245        request->request_type = USB_HUB_REQ_TYPE_SET_PORT_FEATURE;
    … …  
    251249}
    252250
    253 
    254 /** get i`th bit of port status */
    255 static inline bool usb_port_get_bit(usb_port_status_t * status, int idx)
    256 {
    257         return (((*status)>>(idx))%2);
    258 }
    259 
    260 /** set i`th bit of port status */
     251/**
     252 * get i`th bit of port status
     253 *
     254 * @param status
     255 * @param idx
     256 * @return
     257 */
     258static inline bool usb_port_get_bit(usb_port_status_t * status, int idx) {
     259        return (*status)&(1 << idx);
     260}
     261
     262/**
     263 * set i`th bit of port status
     264 *
     265 * @param status
     266 * @param idx
     267 * @param value
     268 */
    261269static inline void usb_port_set_bit(
    262         usb_port_status_t * status, int idx, bool value)
    263 {
    264         (*status) = value?
    265                                ((*status)|(1<<(idx))):
    266                                ((*status)&(~(1<<(idx))));
    267 }
    268 
    269 /** get i`th bit of hub status */
    270 static inline bool usb_hub_get_bit(usb_hub_status_t * status, int idx)
    271 {
    272         return (((*status)>>(idx))%2);
    273 }
    274 
    275 /** set i`th bit of hub status */
     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 */
     283static inline bool usb_hub_get_bit(usb_hub_status_t * status, int idx) {
     284        return (*status)&(1 << idx);
     285}
     286
     287/**
     288 * set i`th bit of hub status
     289 *
     290 * @param status
     291 * @param idx
     292 * @param value
     293 */
    276294static inline void usb_hub_set_bit(
    277         usb_hub_status_t * status, int idx, bool value)
    278 {
    279         (*status) = value?
    280                                ((*status)|(1<<(idx))):
    281                                ((*status)&(~(1<<(idx))));
    282 }
    283 
    284 
    285 //device connnected on port
    286 static inline bool usb_port_dev_connected(usb_port_status_t * status){
    287         return usb_port_get_bit(status,0);
    288 }
    289 
    290 static inline void usb_port_set_dev_connected(usb_port_status_t * status,bool connected){
    291         usb_port_set_bit(status,0,connected);
     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 * connection status geter for port status
     303 *
     304 * @param status
     305 * @return true if there is something connected
     306 */
     307static inline bool usb_port_dev_connected(usb_port_status_t * status) {
     308        return usb_port_get_bit(status, 0);
     309}
     310
     311static inline void usb_port_set_dev_connected(usb_port_status_t * status, bool connected) {
     312        usb_port_set_bit(status, 0, connected);
    292313}
    293314
    294315//port enabled
    295 static inline bool usb_port_enabled(usb_port_status_t * status){
    296         return usb_port_get_bit(status,1);
    297 }
    298 
    299 static inline void usb_port_set_enabled(usb_port_status_t * status,bool enabled){
    300         usb_port_set_bit(status,1,enabled);
     316
     317/**
     318 * port enabled getter for port status
     319 *
     320 * @param status
     321 * @return true if the port is enabled
     322 */
     323static inline bool usb_port_enabled(usb_port_status_t * status) {
     324        return usb_port_get_bit(status, 1);
     325}
     326
     327static inline void usb_port_set_enabled(usb_port_status_t * status, bool enabled) {
     328        usb_port_set_bit(status, 1, enabled);
    301329}
    302330
    303331//port suspended
    304 static inline bool usb_port_suspended(usb_port_status_t * status){
    305         return usb_port_get_bit(status,2);
    306 }
    307 
    308 static inline void usb_port_set_suspended(usb_port_status_t * status,bool suspended){
    309         usb_port_set_bit(status,2,suspended);
     332/**
     333 * port suspended getter for port status
     334 *
     335 * @param status
     336 * @return true if port is suspended
     337 */
     338static inline bool usb_port_suspended(usb_port_status_t * status) {
     339        return usb_port_get_bit(status, 2);
     340}
     341
     342static inline void usb_port_set_suspended(usb_port_status_t * status, bool suspended) {
     343        usb_port_set_bit(status, 2, suspended);
    310344}
    311345
    312346//over currect
    313 static inline bool usb_port_over_current(usb_port_status_t * status){
    314         return usb_port_get_bit(status,3);
    315 }
    316 
    317 static inline void usb_port_set_over_current(usb_port_status_t * status,bool value){
    318         usb_port_set_bit(status,3,value);
     347/**
     348 * over current condition indicator getter for port status
     349 *
     350 * @param status
     351 * @return true if there is opver-current condition on the hub
     352 */
     353static inline bool usb_port_over_current(usb_port_status_t * status) {
     354        return usb_port_get_bit(status, 3);
     355}
     356
     357static inline void usb_port_set_over_current(usb_port_status_t * status, bool value) {
     358        usb_port_set_bit(status, 3, value);
    319359}
    320360
    321361//port reset
    322 static inline bool usb_port_reset(usb_port_status_t * status){
    323         return usb_port_get_bit(status,4);
    324 }
    325 
    326 static inline void usb_port_set_reset(usb_port_status_t * status,bool value){
    327         usb_port_set_bit(status,4,value);
     362/**
     363 * port reset indicator getter for port status
     364 *
     365 * @param status
     366 * @return true if port is reset
     367 */
     368static inline bool usb_port_reset(usb_port_status_t * status) {
     369        return usb_port_get_bit(status, 4);
     370}
     371
     372static inline void usb_port_set_reset(usb_port_status_t * status, bool value) {
     373        usb_port_set_bit(status, 4, value);
    328374}
    329375
    330376//powered
    331 static inline bool usb_port_powered(usb_port_status_t * status){
    332         return usb_port_get_bit(status,8);
    333 }
    334 
    335 static inline void usb_port_set_powered(usb_port_status_t * status,bool powered){
    336         usb_port_set_bit(status,8,powered);
     377/**
     378 * power state getter for port status
     379 *
     380 * @param status
     381 * @return true if port is powered
     382 */
     383static inline bool usb_port_powered(usb_port_status_t * status) {
     384        return usb_port_get_bit(status, 8);
     385}
     386
     387static inline void usb_port_set_powered(usb_port_status_t * status, bool powered) {
     388        usb_port_set_bit(status, 8, powered);
    337389}
    338390
    339391//low speed device attached
    340 static inline bool usb_port_low_speed(usb_port_status_t * status){
    341         return usb_port_get_bit(status,9);
    342 }
    343 
    344 static inline void usb_port_set_low_speed(usb_port_status_t * status,bool low_speed){
    345         usb_port_set_bit(status,9,low_speed);
    346 }
    347 
    348 //low speed device attached
    349 static inline bool usb_port_high_speed(usb_port_status_t * status){
    350         return usb_port_get_bit(status,10);
    351 }
    352 
    353 static inline void usb_port_set_high_speed(usb_port_status_t * status,bool high_speed){
    354         usb_port_set_bit(status,10,high_speed);
    355 }
    356 
    357 static inline usb_speed_t usb_port_speed(usb_port_status_t * status){
    358         if(usb_port_low_speed(status))
     392/**
     393 * low speed device on the port indicator
     394 *
     395 * @param status
     396 * @return true if low speed device is attached
     397 */
     398static inline bool usb_port_low_speed(usb_port_status_t * status) {
     399        return usb_port_get_bit(status, 9);
     400}
     401
     402static inline void usb_port_set_low_speed(usb_port_status_t * status, bool low_speed) {
     403        usb_port_set_bit(status, 9, low_speed);
     404}
     405
     406//high speed device attached
     407/**
     408 * high speed device on the port indicator
     409 *
     410 * @param status
     411 * @return true if high speed device is on port
     412 */
     413static inline bool usb_port_high_speed(usb_port_status_t * status) {
     414        return usb_port_get_bit(status, 10);
     415}
     416
     417static inline void usb_port_set_high_speed(usb_port_status_t * status, bool high_speed) {
     418        usb_port_set_bit(status, 10, high_speed);
     419}
     420
     421/**
     422 * speed getter for port status
     423 *
     424 * @param status
     425 * @return speed of usb device (for more see usb specification)
     426 */
     427static inline usb_speed_t usb_port_speed(usb_port_status_t * status) {
     428        if (usb_port_low_speed(status))
    359429                return USB_SPEED_LOW;
    360         if(usb_port_high_speed(status))
     430        if (usb_port_high_speed(status))
    361431                return USB_SPEED_HIGH;
    362432        return USB_SPEED_FULL;
    … …  
    365435
    366436//connect change
    367 static inline bool usb_port_connect_change(usb_port_status_t * status){
    368         return usb_port_get_bit(status,16);
    369 }
    370 
    371 static inline void usb_port_set_connect_change(usb_port_status_t * status,bool change){
    372         usb_port_set_bit(status,16,change);
     437/**
     438 * port connect change indicator
     439 *
     440 * @param status
     441 * @return true if connection has changed
     442 */
     443static inline bool usb_port_connect_change(usb_port_status_t * status) {
     444        return usb_port_get_bit(status, 16);
     445}
     446
     447static inline void usb_port_set_connect_change(usb_port_status_t * status, bool change) {
     448        usb_port_set_bit(status, 16, change);
    373449}
    374450
    375451//port enable change
    376 static inline bool usb_port_enabled_change(usb_port_status_t * status){
    377         return usb_port_get_bit(status,17);
    378 }
    379 
    380 static inline void usb_port_set_enabled_change(usb_port_status_t * status,bool change){
    381         usb_port_set_bit(status,17,change);
     452/**
     453 * port enable change for port status
     454 *
     455 * @param status
     456 * @return true if the port has been enabled/disabled
     457 */
     458static inline bool usb_port_enabled_change(usb_port_status_t * status) {
     459        return usb_port_get_bit(status, 17);
     460}
     461
     462static inline void usb_port_set_enabled_change(usb_port_status_t * status, bool change) {
     463        usb_port_set_bit(status, 17, change);
    382464}
    383465
    384466//suspend change
    385 static inline bool usb_port_suspend_change(usb_port_status_t * status){
    386         return usb_port_get_bit(status,18);
    387 }
    388 
    389 static inline void usb_port_set_suspend_change(usb_port_status_t * status,bool change){
    390         usb_port_set_bit(status,18,change);
     467/**
     468 * port suspend change for port status
     469 *
     470 * @param status
     471 * @return ture if suspend status has changed
     472 */
     473static inline bool usb_port_suspend_change(usb_port_status_t * status) {
     474        return usb_port_get_bit(status, 18);
     475}
     476
     477static inline void usb_port_set_suspend_change(usb_port_status_t * status, bool change) {
     478        usb_port_set_bit(status, 18, change);
    391479}
    392480
    393481//over current change
    394 static inline bool usb_port_overcurrent_change(usb_port_status_t * status){
    395         return usb_port_get_bit(status,19);
    396 }
    397 
    398 static inline void usb_port_set_overcurrent_change(usb_port_status_t * status,bool change){
    399         usb_port_set_bit(status,19,change);
     482/**
     483 * over current change indicator
     484 *
     485 * @param status
     486 * @return true if over-current condition on port has changed
     487 */
     488static inline bool usb_port_overcurrent_change(usb_port_status_t * status) {
     489        return usb_port_get_bit(status, 19);
     490}
     491
     492static inline void usb_port_set_overcurrent_change(usb_port_status_t * status, bool change) {
     493        usb_port_set_bit(status, 19, change);
    400494}
    401495
    402496//reset change
    403 static inline bool usb_port_reset_completed(usb_port_status_t * status){
    404         return usb_port_get_bit(status,20);
    405 }
    406 
    407 static inline void usb_port_set_reset_completed(usb_port_status_t * status,bool completed){
    408         usb_port_set_bit(status,20,completed);
     497/**
     498 * port reset change indicator
     499 * @param status
     500 * @return true if port has been reset
     501 */
     502static inline bool usb_port_reset_completed(usb_port_status_t * status) {
     503        return usb_port_get_bit(status, 20);
     504}
     505
     506static inline void usb_port_set_reset_completed(usb_port_status_t * status, bool completed) {
     507        usb_port_set_bit(status, 20, completed);
    409508}
    410509
    411510//local power status
    412 static inline bool usb_hub_local_power_lost(usb_hub_status_t * status){
    413         return usb_hub_get_bit(status,0);
     511/**
     512 * local power lost indicator for hub status
     513 *
     514 * @param status
     515 * @return true if hub is not powered
     516 */
     517static inline bool usb_hub_local_power_lost(usb_hub_status_t * status) {
     518        return usb_hub_get_bit(status, 0);
    414519}
    415520
    416521static inline void usb_hub_set_local_power_lost(usb_port_status_t * status,
    417         bool power_lost){
    418         usb_hub_set_bit(status,0,power_lost);
     522        bool power_lost) {
     523        usb_hub_set_bit(status, 0, power_lost);
    419524}
    420525
    421526//over current ocndition
    422 static inline bool usb_hub_over_current(usb_hub_status_t * status){
    423         return usb_hub_get_bit(status,1);
     527/**
     528 * hub over-current indicator
     529 *
     530 * @param status
     531 * @return true if over-current condition occurred on hub
     532 */
     533static inline bool usb_hub_over_current(usb_hub_status_t * status) {
     534        return usb_hub_get_bit(status, 1);
    424535}
    425536
    426537static inline void usb_hub_set_over_current(usb_port_status_t * status,
    427         bool over_current){
    428         usb_hub_set_bit(status,1,over_current);
     538        bool over_current) {
     539        usb_hub_set_bit(status, 1, over_current);
    429540}
    430541
    431542//local power change
    432 static inline bool usb_hub_local_power_change(usb_hub_status_t * status){
    433         return usb_hub_get_bit(status,16);
     543/**
     544 * hub power change indicator
     545 *
     546 * @param status
     547 * @return true if local power status has been changed - power has been
     548 * dropped or re-established
     549 */
     550static inline bool usb_hub_local_power_change(usb_hub_status_t * status) {
     551        return usb_hub_get_bit(status, 16);
    434552}
    435553
    436554static inline void usb_hub_set_local_power_change(usb_port_status_t * status,
    437         bool change){
    438         usb_hub_set_bit(status,16,change);
     555        bool change) {
     556        usb_hub_set_bit(status, 16, change);
    439557}
    440558
    441559//local power status
    442 static inline bool usb_hub_over_current_change(usb_hub_status_t * status){
    443         return usb_hub_get_bit(status,17);
     560/**
     561 * hub over-current condition change indicator
     562 *
     563 * @param status
     564 * @return true if over-current condition has changed
     565 */
     566static inline bool usb_hub_over_current_change(usb_hub_status_t * status) {
     567        return usb_hub_get_bit(status, 17);
    444568}
    445569
    446570static inline void usb_hub_set_over_current_change(usb_port_status_t * status,
    447         bool change){
    448         usb_hub_set_bit(status,17,change);
     571        bool change) {
     572        usb_hub_set_bit(status, 17, change);
    449573}
    450574

  • uspace/drv/usbhub/usbhub.c

    r90d0522 r3dba1ca  
    7676                async_usleep(1000 * 1000 * 10); /// \TODO proper number once
    7777                errorCode = usb_hub_check_hub_changes(hub_info);
    78 
    7978        }
    8079        usb_log_error("something in ctrl loop went wrong, errno %d\n",
    … …  
    8584
    8685/// \TODO set_port_feature use
     86/// \TODO unmess code
    8787
    8888//*********************************************
    … …  
    766766}
    767767
     768/**
     769 * process hub over current change
     770 *
     771 * This means either to power off the hub or power it on.
     772 * @param hub_info hub instance
     773 * @param status hub status bitmask
     774 * @return error code
     775 */
    768776static int usb_process_hub_over_current(usb_hub_info_t * hub_info,
    769777        usb_hub_status_t status)
    … …  
    788796}
    789797
     798/**
     799 * process hub power change
     800 *
     801 * If the power has been lost, reestablish it.
     802 * If it was reestablished, re-power all ports.
     803 * @param hub_info hub instance
     804 * @param status hub status bitmask
     805 * @return error code
     806 */
    790807static int usb_process_hub_power_change(usb_hub_info_t * hub_info,
    791808        usb_hub_status_t status)
    … …  
    815832}
    816833
    817 
     834/**
     835 * process hub interrupts
     836 *
     837 * The change can be either in the over-current condition or
     838 * local-power lost condition.
     839 * @param hub_info hub instance
     840 */
    818841static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info){
    819842        usb_log_debug("global interrupt on a hub\n");
    … …  
    850873}
    851874
     875/**
     876 * this is an attempt to initialize non-removable devices in the hub
     877 *
     878 * @param hub_info hub instance
     879 * @param port port number, counting from 1
     880 * @return error code
     881 */
    852882static int initialize_non_removable(usb_hub_info_t * hub_info,
    853883        unsigned int port) {
Note: See TracChangeset for help on using the changeset viewer.