Changeset 6ab7f3e9 in mainline


Ignore:
Timestamp:
2011-05-29T21:53:34Z (13 years ago)
Author:
Matus Dekanek <smekideki@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
98e15b1
Parents:
5c1a65e
Message:

some code tiding

Location:
uspace/drv
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/root_hub.c

    r5c1a65e r6ab7f3e9  
    117117 */
    118118static const uint32_t hub_clear_feature_by_writing_one_mask =
    119    RHS_CLEAR_PORT_POWER;
     119    RHS_CLEAR_PORT_POWER;
    120120
    121121/**
    … …  
    412412        request->transfered_size = 4;
    413413        uint32_t data = instance->registers->rh_port_status[port - 1];
    414         memcpy(request->data_buffer,&data,4);
     414        memcpy(request->data_buffer, &data, 4);
    415415#if 0
    416416        int i;
    … …  
    445445        uint32_t data = mask & instance->registers->rh_status;
    446446        //uint32_buffer[0] = mask & instance->registers->rh_status;
    447         memcpy(request->data_buffer,&data,4);
     447        memcpy(request->data_buffer, &data, 4);
    448448
    449449        return EOK;
    … …  
    499499            | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
    500500        bzero(bitmap, instance->interrupt_mask_size);
    501         if ((instance->registers->rh_status & mask) !=0 ) {
     501        if ((instance->registers->rh_status & mask) != 0) {
    502502                bitmap[0] = 1;
    503503        }
    … …  
    925925 * @return
    926926 */
    927 static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request) {
     927static int process_interrupt_mask_in_instance(rh_t *instance,
     928    usb_transfer_batch_t * request) {
    928929        memcpy(request->data_buffer, instance->interrupt_buffer,
    929930            instance->interrupt_mask_size);
    … …  
    945946 * @return
    946947 */
    947 static bool is_zeros(void * buffer, size_t size) {
     948static bool is_zeros(void *buffer, size_t size) {
    948949        if (!buffer) return true;
    949950        if (!size) return true;

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

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

  • uspace/drv/usbhub/port_status.h

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

  • uspace/drv/usbhub/ports.h

    r5c1a65e r6ab7f3e9  
    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

    r5c1a65e r6ab7f3e9  
    7373
    7474static void usb_hub_polling_terminated_callback(usb_device_t *device,
    75     bool was_error, void * data);
     75    bool was_error, void *data);
    7676
    7777

  • uspace/drv/usbhub/usbhub.h

    r5c1a65e r6ab7f3e9  
    5151#include "ports.h"
    5252
    53 
    54 
    5553/** Information about attached hub. */
    56 struct usb_hub_info_t{
     54struct usb_hub_info_t {
    5755        /** Number of ports. */
    5856        size_t port_count;
    … …  
    106104};
    107105
    108 //int usb_hub_control_loop(void * hub_info_param);
    109 
    110 int usb_hub_add_device(usb_device_t * usb_dev);
     106int usb_hub_add_device(usb_device_t *usb_dev);
    111107
    112108bool hub_port_changes_callback(usb_device_t *dev,

  • uspace/drv/usbhub/usbhub_private.h

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

  • uspace/drv/usbhub/utils.c

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