Changeset 20a3465 in mainline for uspace/lib/usbdev


Ignore:
Timestamp:
2011-10-30T19:50:54Z (14 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
3ce78580, 48902fa
Parents:
4c3ad56 (diff), 45bf63c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

Location:
uspace/lib/usbdev
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r4c3ad56 r20a3465  
    5959typedef struct {
    6060        /** Used descriptor nesting. */
    61         usb_dp_descriptor_nesting_t *nesting;
     61        const usb_dp_descriptor_nesting_t *nesting;
    6262} usb_dp_parser_t;
    6363
    … …  
    6565typedef struct {
    6666        /** Data to be parsed. */
    67         uint8_t *data;
     67        const uint8_t *data;
    6868        /** Size of input data in bytes. */
    6969        size_t size;
    … …  
    7272} usb_dp_parser_data_t;
    7373
    74 uint8_t *usb_dp_get_nested_descriptor(usb_dp_parser_t *,
    75     usb_dp_parser_data_t *, uint8_t *);
    76 uint8_t *usb_dp_get_sibling_descriptor(usb_dp_parser_t *,
    77     usb_dp_parser_data_t *, uint8_t *, uint8_t *);
     74typedef void (*walk_callback_t)(const uint8_t *, size_t, void *);
    7875
    79 void usb_dp_walk_simple(uint8_t *, size_t, usb_dp_descriptor_nesting_t *,
    80     void (*)(uint8_t *, size_t, void *), void *);
     76const uint8_t *usb_dp_get_nested_descriptor(const usb_dp_parser_t *,
     77    const usb_dp_parser_data_t *, const uint8_t *);
     78const uint8_t *usb_dp_get_sibling_descriptor(const usb_dp_parser_t *,
     79    const usb_dp_parser_data_t *, const uint8_t *, const uint8_t *);
     80
     81void usb_dp_walk_simple(uint8_t *, size_t, const usb_dp_descriptor_nesting_t *,
     82    walk_callback_t, void *);
    8183
    8284#endif

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

    r4c3ad56 r20a3465  
    4343        usb_standard_device_descriptor_t device;
    4444        /** Full configuration descriptor of current configuration. */
    45         uint8_t *configuration;
     45        const uint8_t *configuration;
    4646        size_t configuration_size;
    4747} usb_device_descriptors_t;
    … …  
    5353typedef struct {
    5454        /** Interface descriptor. */
    55         usb_standard_interface_descriptor_t *interface;
     55        const usb_standard_interface_descriptor_t *interface;
    5656        /** Pointer to start of descriptor tree bound with this interface. */
    57         uint8_t *nested_descriptors;
     57        const uint8_t *nested_descriptors;
    5858        /** Size of data pointed by nested_descriptors in bytes. */
    5959        size_t nested_descriptors_size;
    … …  
    156156\endcode
    157157         */
    158         usb_endpoint_description_t **endpoints;
     158        const usb_endpoint_description_t **endpoints;
    159159        /** Driver ops. */
    160         usb_driver_ops_t *ops;
     160        const usb_driver_ops_t *ops;
    161161} usb_driver_t;
    162162
    163 int usb_driver_main(usb_driver_t *);
     163int usb_driver_main(const usb_driver_t *);
    164164
    165165int usb_device_select_interface(usb_device_t *, uint8_t,
    166     usb_endpoint_description_t **);
     166    const usb_endpoint_description_t **);
    167167
    168168int usb_device_retrieve_descriptors(usb_pipe_t *, usb_device_descriptors_t *);
    169169int usb_device_create_pipes(const ddf_dev_t *, usb_device_connection_t *,
    170     usb_endpoint_description_t **, uint8_t *, size_t, int, int,
     170    const usb_endpoint_description_t **, const uint8_t *, size_t, int, int,
    171171    usb_endpoint_mapping_t **, size_t *);
    172172int usb_device_destroy_pipes(const ddf_dev_t *, usb_endpoint_mapping_t *, size_t);
    173 int usb_device_create(ddf_dev_t *, usb_endpoint_description_t **, usb_device_t **, const char **);
    174 void usb_device_destroy(usb_device_t *);
     173int usb_device_init(usb_device_t *, ddf_dev_t *,
     174    const usb_endpoint_description_t **, const char **);
     175void usb_device_deinit(usb_device_t *);
    175176
    176 size_t usb_interface_count_alternates(uint8_t *, size_t, uint8_t);
    177 int usb_alternate_interfaces_create(uint8_t *, size_t, int,
     177void * usb_device_data_alloc(usb_device_t *, size_t);
     178
     179size_t usb_interface_count_alternates(const uint8_t *, size_t, uint8_t);
     180int usb_alternate_interfaces_create(const uint8_t *, size_t, int,
    178181    usb_alternate_interfaces_t **);
    179 
     182void usb_alternate_interfaces_destroy(usb_alternate_interfaces_t *);
    180183#endif
    181184/**

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

    r4c3ad56 r20a3465  
    171171int usb_pipe_probe_default_control(usb_pipe_t *);
    172172int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
    173     size_t, uint8_t *, size_t, usb_device_connection_t *);
     173    size_t, const uint8_t *, size_t, usb_device_connection_t *);
    174174int usb_pipe_register_with_speed(usb_pipe_t *, usb_speed_t,
    175175    unsigned int, usb_hc_connection_t *);

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

    r4c3ad56 r20a3465  
    4848 * @return Number of alternate interfaces for @p interface_no interface.
    4949 */
    50 size_t usb_interface_count_alternates(uint8_t *config_descr,
     50size_t usb_interface_count_alternates(const uint8_t *config_descr,
    5151    size_t config_descr_size, uint8_t interface_no)
    5252{
    … …  
    5454        assert(config_descr_size > 0);
    5555
    56         usb_dp_parser_t dp_parser = {
     56        const usb_dp_parser_t dp_parser = {
    5757                .nesting = usb_dp_standard_descriptor_nesting
    5858        };
    59         usb_dp_parser_data_t dp_data = {
     59        const usb_dp_parser_data_t dp_data = {
    6060                .data = config_descr,
    6161                .size = config_descr_size,
    … …  
    6565        size_t alternate_count = 0;
    6666
    67         uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
     67        const uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
    6868            &dp_data, config_descr);
    6969        while (iface_ptr != NULL) {
    … …  
    9090 * @return Error code.
    9191 */
    92 int usb_alternate_interfaces_create(uint8_t *config_descr,
     92int usb_alternate_interfaces_create(const uint8_t *config_descr,
    9393    size_t config_descr_size, int interface_number,
    9494    usb_alternate_interfaces_t **alternates_ptr)
    … …  
    9898        assert(config_descr_size > 0);
    9999
     100        *alternates_ptr = NULL;
    100101        if (interface_number < 0) {
    101                 alternates_ptr = NULL;
    102102                return EOK;
    103103        }
    … …  
    105105        usb_alternate_interfaces_t *alternates
    106106            = malloc(sizeof(usb_alternate_interfaces_t));
    107 
    108107        if (alternates == NULL) {
    109108                return ENOMEM;
    … …  
    119118        }
    120119
    121         alternates->alternatives = malloc(alternates->alternative_count
    122             * sizeof(usb_alternate_interface_descriptors_t));
     120        alternates->alternatives = calloc(alternates->alternative_count,
     121            sizeof(usb_alternate_interface_descriptors_t));
    123122        if (alternates->alternatives == NULL) {
    124123                free(alternates);
    … …  
    140139            = &alternates->alternatives[0];
    141140
    142         uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
     141        const uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
    143142            &dp_data, dp_data.data);
    144143        while (iface_ptr != NULL) {
    … …  
    160159                    dp_data.data, iface_ptr);
    161160                if (iface_ptr == NULL) {
    162                         uint8_t *next = dp_data.data + dp_data.size;
     161                        const uint8_t *next = dp_data.data + dp_data.size;
    163162                        cur_alt_iface->nested_descriptors_size
    164163                            = next - cur_alt_iface->nested_descriptors;
    … …  
    176175}
    177176
    178 
     177void usb_alternate_interfaces_destroy(usb_alternate_interfaces_t *alternate)
     178{
     179        if (!alternate)
     180                return;
     181        free(alternate->alternatives);
     182        free(alternate);
     183}
    179184/**
    180185 * @}

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

    r4c3ad56 r20a3465  
    5454};
    5555
    56 static usb_driver_t *driver = NULL;
     56static const usb_driver_t *driver = NULL;
    5757
    5858
    … …  
    6464 * @return Task exit status.
    6565 */
    66 int usb_driver_main(usb_driver_t *drv)
     66int usb_driver_main(const usb_driver_t *drv)
    6767{
    6868        assert(drv != NULL);
    … …  
    8181 * @return Number of pipes (excluding default control pipe).
    8282 */
    83 static size_t count_other_pipes(usb_endpoint_description_t **endpoints)
     83static size_t count_other_pipes(const usb_endpoint_description_t **endpoints)
    8484{
    8585        size_t count = 0;
    … …  
    101101 * @return Error code.
    102102 */
    103 static int initialize_other_pipes(usb_endpoint_description_t **endpoints,
     103static int initialize_other_pipes(const usb_endpoint_description_t **endpoints,
    104104    usb_device_t *dev, int alternate_setting)
    105105{
    … …  
    115115        int rc = usb_device_create_pipes(dev->ddf_dev, &dev->wire, endpoints,
    116116            dev->descriptors.configuration, dev->descriptors.configuration_size,
    117             dev->interface_no, alternate_setting,
    118             &pipes, &pipes_count);
     117            dev->interface_no, alternate_setting, &pipes, &pipes_count);
    119118
    120119        if (rc != EOK) {
    … …  
    141140        assert(driver->ops->device_add);
    142141
    143         int rc;
    144 
    145         usb_device_t *dev = NULL;
     142        usb_device_t *dev = ddf_dev_data_alloc(gen_dev, sizeof(usb_device_t));
     143        if (dev == NULL) {
     144                usb_log_error("USB device `%s' structure allocation failed.\n",
     145                    gen_dev->name);
     146                return ENOMEM;
     147        }
    146148        const char *err_msg = NULL;
    147         rc = usb_device_create(gen_dev, driver->endpoints, &dev, &err_msg);
    148         if (rc != EOK) {
    149                 usb_log_error("USB device `%s' creation failed (%s): %s.\n",
     149        int rc = usb_device_init(dev, gen_dev, driver->endpoints, &err_msg);
     150        if (rc != EOK) {
     151                usb_log_error("USB device `%s' init failed (%s): %s.\n",
    150152                    gen_dev->name, err_msg, str_error(rc));
    151153                return rc;
    152154        }
    153         gen_dev->driver_data = dev;
    154 
    155         return driver->ops->device_add(dev);
     155
     156        rc = driver->ops->device_add(dev);
     157        if (rc != EOK)
     158                usb_device_deinit(dev);
     159        return rc;
    156160}
    157161/*----------------------------------------------------------------------------*/
    … …  
    186190        if (driver->ops->device_gone == NULL)
    187191                return ENOTSUP;
    188         const int ret = driver->ops->device_gone(gen_dev->driver_data);
     192        usb_device_t *usb_dev = gen_dev->driver_data;
     193        const int ret = driver->ops->device_gone(usb_dev);
    189194        if (ret == EOK)
    190                 usb_device_destroy(gen_dev->driver_data);
     195                usb_device_deinit(usb_dev);
    191196
    192197        return ret;
    … …  
    235240 */
    236241int usb_device_select_interface(usb_device_t *dev, uint8_t alternate_setting,
    237     usb_endpoint_description_t **endpoints)
     242    const usb_endpoint_description_t **endpoints)
    238243{
    239244        if (dev->interface_no < 0) {
    … …  
    318323 */
    319324int usb_device_create_pipes(const ddf_dev_t *dev, usb_device_connection_t *wire,
    320     usb_endpoint_description_t **endpoints,
    321     uint8_t *config_descr, size_t config_descr_size,
     325    const usb_endpoint_description_t **endpoints,
     326    const uint8_t *config_descr, size_t config_descr_size,
    322327    int interface_no, int interface_setting,
    323328    usb_endpoint_mapping_t **pipes_ptr, size_t *pipes_count_ptr)
    … …  
    333338        int rc;
    334339
    335         size_t pipe_count = count_other_pipes(endpoints);
     340        const size_t pipe_count = count_other_pipes(endpoints);
    336341        if (pipe_count == 0) {
     342                *pipes_count_ptr = pipe_count;
    337343                *pipes_ptr = NULL;
    338344                return EOK;
    … …  
    445451{
    446452        assert(dev != NULL);
    447         assert(((pipes != NULL) && (pipes_count > 0))
    448             || ((pipes == NULL) && (pipes_count == 0)));
    449453
    450454        if (pipes_count == 0) {
     455                assert(pipes == NULL);
    451456                return EOK;
    452457        }
     458        assert(pipes != NULL);
    453459
    454460        int rc;
    … …  
    468474        size_t i;
    469475        for (i = 0; i < pipes_count; i++) {
    470                 usb_pipe_unregister(pipes[i].pipe, &hc_conn);
     476                usb_log_debug2("Unregistering pipe %zu (%spresent).\n",
     477                    i, pipes[i].present ? "" : "not ");
     478                if (pipes[i].present)
     479                        usb_pipe_unregister(pipes[i].pipe, &hc_conn);
    471480                free(pipes[i].pipe);
    472481        }
    … …  
    509518
    510519
    511 /** Create new instance of USB device.
    512  *
     520/** Initialize new instance of USB device.
     521 *
     522 * @param[in] usb_dev Pointer to the new device.
    513523 * @param[in] ddf_dev Generic DDF device backing the USB one.
    514524 * @param[in] endpoints NULL terminated array of endpoints (NULL for none).
    515  * @param[out] dev_ptr Where to store pointer to the new device.
    516525 * @param[out] errstr_ptr Where to store description of context
    517526 *      (in case error occurs).
    518527 * @return Error code.
    519528 */
    520 int usb_device_create(ddf_dev_t *ddf_dev,
    521     usb_endpoint_description_t **endpoints,
    522     usb_device_t **dev_ptr, const char **errstr_ptr)
    523 {
    524         assert(dev_ptr != NULL);
     529int usb_device_init(usb_device_t *usb_dev, ddf_dev_t *ddf_dev,
     530    const usb_endpoint_description_t **endpoints, const char **errstr_ptr)
     531{
     532        assert(usb_dev != NULL);
    525533        assert(ddf_dev != NULL);
    526534
    527         int rc;
    528 
    529         usb_device_t *dev = malloc(sizeof(usb_device_t));
    530         if (dev == NULL) {
    531                 *errstr_ptr = "structure allocation";
    532                 return ENOMEM;
    533         }
    534 
    535         // FIXME: proper deallocation in case of errors
    536 
    537         dev->ddf_dev = ddf_dev;
    538         dev->driver_data = NULL;
    539         dev->descriptors.configuration = NULL;
    540         dev->alternate_interfaces = NULL;
    541 
    542         dev->pipes_count = 0;
    543         dev->pipes = NULL;
     535        usb_dev->ddf_dev = ddf_dev;
     536        usb_dev->driver_data = NULL;
     537        usb_dev->descriptors.configuration = NULL;
     538        usb_dev->alternate_interfaces = NULL;
     539        usb_dev->pipes_count = 0;
     540        usb_dev->pipes = NULL;
    544541
    545542        /* Initialize backing wire and control pipe. */
    546         rc = init_wire_and_ctrl_pipe(dev, errstr_ptr);
     543        int rc = init_wire_and_ctrl_pipe(usb_dev, errstr_ptr);
    547544        if (rc != EOK) {
    548545                return rc;
    … …  
    550547
    551548        /* Get our interface. */
    552         dev->interface_no = usb_device_get_assigned_interface(dev->ddf_dev);
     549        usb_dev->interface_no = usb_device_get_assigned_interface(ddf_dev);
    553550
    554551        /* Retrieve standard descriptors. */
    555         rc = usb_device_retrieve_descriptors(&dev->ctrl_pipe,
    556             &dev->descriptors);
    557         if (rc != EOK) {
     552        rc = usb_device_retrieve_descriptors(&usb_dev->ctrl_pipe,
     553            &usb_dev->descriptors);
     554        if (rc != EOK) {
     555                /* Nothing allocated, nothing to free. */
    558556                *errstr_ptr = "descriptor retrieval";
    559557                return rc;
    560558        }
    561559
    562         /* Create alternate interfaces. */
    563         rc = usb_alternate_interfaces_create(dev->descriptors.configuration,
    564             dev->descriptors.configuration_size, dev->interface_no,
    565             &dev->alternate_interfaces);
    566         if (rc != EOK) {
    567                 /* We will try to silently ignore this. */
    568                 dev->alternate_interfaces = NULL;
    569         }
    570 
    571         rc = initialize_other_pipes(endpoints, dev, 0);
    572         if (rc != EOK) {
     560        /* Create alternate interfaces. We will silently ignore failure. */
     561        //TODO Why ignore?
     562        usb_alternate_interfaces_create(usb_dev->descriptors.configuration,
     563            usb_dev->descriptors.configuration_size, usb_dev->interface_no,
     564            &usb_dev->alternate_interfaces);
     565
     566        rc = initialize_other_pipes(endpoints, usb_dev, 0);
     567        if (rc != EOK) {
     568                /* Full configuration descriptor is allocated. */
     569                free(usb_dev->descriptors.configuration);
     570                /* Alternate interfaces may be allocated */
     571                usb_alternate_interfaces_destroy(usb_dev->alternate_interfaces);
    573572                *errstr_ptr = "pipes initialization";
    574573                return rc;
    … …  
    576575
    577576        *errstr_ptr = NULL;
    578         *dev_ptr = dev;
    579577
    580578        return EOK;
    581579}
    582580
    583 /** Destroy instance of a USB device.
    584  *
    585  * @param dev Device to be destroyed.
    586  */
    587 void usb_device_destroy(usb_device_t *dev)
    588 {
    589         if (dev == NULL) {
    590                 return;
    591         }
    592 
    593         /* Ignore errors and hope for the best. */
    594         usb_device_destroy_pipes(dev->ddf_dev, dev->pipes, dev->pipes_count);
    595         free(dev->descriptors.configuration);
    596 
    597         if (dev->alternate_interfaces != NULL) {
    598                 free(dev->alternate_interfaces->alternatives);
    599         }
    600         free(dev->alternate_interfaces);
    601 
    602         free(dev);
     581/** Clean instance of a USB device.
     582 *
     583 * @param dev Device to be de-initialized.
     584 *
     585 * Does not free/destroy supplied pointer.
     586 */
     587void usb_device_deinit(usb_device_t *dev)
     588{
     589        if (dev) {
     590                /* Ignore errors and hope for the best. */
     591                destroy_current_pipes(dev);
     592
     593                usb_alternate_interfaces_destroy(dev->alternate_interfaces);
     594                free(dev->descriptors.configuration);
     595                free(dev->driver_data);
     596        }
     597}
     598
     599void * usb_device_data_alloc(usb_device_t *usb_dev, size_t size)
     600{
     601        assert(usb_dev);
     602        assert(usb_dev->driver_data == NULL);
     603        return usb_dev->driver_data = calloc(1, size);
     604
    603605}
    604606

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

    r4c3ad56 r20a3465  
    7575 * @return Whether @p ptr points inside <code>data->data</code> field.
    7676 */
    77 static bool is_valid_descriptor_pointer(usb_dp_parser_data_t *data,
    78     uint8_t *ptr)
     77static bool is_valid_descriptor_pointer(const usb_dp_parser_data_t *data,
     78    const uint8_t *ptr)
    7979{
    8080        if (ptr == NULL) {
    … …  
    100100 * @retval NULL Invalid input or no next descriptor.
    101101 */
    102 static uint8_t *get_next_descriptor(usb_dp_parser_data_t *data,
    103     uint8_t *current)
     102static const uint8_t *get_next_descriptor(const usb_dp_parser_data_t *data,
     103    const uint8_t *current)
    104104{
    105105        assert(is_valid_descriptor_pointer(data, current));
    106106
    107         uint8_t current_length = *current;
    108         uint8_t *next = current + current_length;
     107        const uint8_t current_length = *current;
     108        const uint8_t *next = current + current_length;
    109109
    110110        if (!is_valid_descriptor_pointer(data, next)) {
    … …  
    124124 * @retval -1 Invalid input.
    125125 */
    126 static int get_descriptor_type(usb_dp_parser_data_t *data, uint8_t *start)
     126static int get_descriptor_type(const usb_dp_parser_data_t *data, const uint8_t *start)
    127127{
    128128        if (start == NULL) {
    … …  
    145145 * @return Whether @p child could be child of @p parent.
    146146 */
    147 static bool is_nested_descriptor_type(usb_dp_parser_t *parser,
     147static bool is_nested_descriptor_type(const usb_dp_parser_t *parser,
    148148    int child, int parent)
    149149{
    150         usb_dp_descriptor_nesting_t *nesting = parser->nesting;
     150        const usb_dp_descriptor_nesting_t *nesting = parser->nesting;
    151151        while ((nesting->child > 0) && (nesting->parent > 0)) {
    152152                if ((nesting->child == child) && (nesting->parent == parent)) {
    … …  
    166166 * @return Whether @p child could be child of @p parent.
    167167 */
    168 static bool is_nested_descriptor(usb_dp_parser_t *parser,
    169     usb_dp_parser_data_t *data, uint8_t *child, uint8_t *parent)
     168static bool is_nested_descriptor(const usb_dp_parser_t *parser,
     169    const usb_dp_parser_data_t *data, const uint8_t *child, const uint8_t *parent)
    170170{
    171171        return is_nested_descriptor_type(parser,
    … …  
    183183 * @retval NULL Invalid input.
    184184 */
    185 uint8_t *usb_dp_get_nested_descriptor(usb_dp_parser_t *parser,
    186     usb_dp_parser_data_t *data, uint8_t *parent)
     185const uint8_t *usb_dp_get_nested_descriptor(const usb_dp_parser_t *parser,
     186    const usb_dp_parser_data_t *data, const uint8_t *parent)
    187187{
    188188        if (!is_valid_descriptor_pointer(data, parent)) {
    … …  
    190190        }
    191191
    192         uint8_t *next = get_next_descriptor(data, parent);
     192        const uint8_t *next = get_next_descriptor(data, parent);
    193193        if (next == NULL) {
    194194                return NULL;
    … …  
    211211 * @retval NULL Invalid input.
    212212 */
    213 static uint8_t *skip_nested_descriptors(usb_dp_parser_t *parser,
    214     usb_dp_parser_data_t *data, uint8_t *parent)
    215 {
    216         uint8_t *child = usb_dp_get_nested_descriptor(parser, data, parent);
     213static const uint8_t *skip_nested_descriptors(const usb_dp_parser_t *parser,
     214    const usb_dp_parser_data_t *data, const uint8_t *parent)
     215{
     216        const uint8_t *child =
     217            usb_dp_get_nested_descriptor(parser, data, parent);
    217218        if (child == NULL) {
    218219                return get_next_descriptor(data, parent);
    219220        }
    220         uint8_t *next_child = skip_nested_descriptors(parser, data, child);
     221        const uint8_t *next_child =
     222            skip_nested_descriptors(parser, data, child);
    221223        while (is_nested_descriptor(parser, data, next_child, parent)) {
    222224                next_child = skip_nested_descriptors(parser, data, next_child);
    … …  
    236238 * @retval NULL Invalid input.
    237239 */
    238 uint8_t *usb_dp_get_sibling_descriptor(usb_dp_parser_t *parser,
    239     usb_dp_parser_data_t *data, uint8_t *parent, uint8_t *sibling)
     240const uint8_t *usb_dp_get_sibling_descriptor(
     241    const usb_dp_parser_t *parser, const usb_dp_parser_data_t *data,
     242    const uint8_t *parent, const uint8_t *sibling)
    240243{
    241244        if (!is_valid_descriptor_pointer(data, parent)
    … …  
    244247        }
    245248
    246         uint8_t *possible_sibling = skip_nested_descriptors(parser, data, sibling);
     249        const uint8_t *possible_sibling =
     250            skip_nested_descriptors(parser, data, sibling);
    247251        if (possible_sibling == NULL) {
    248252                return NULL;
    … …  
    269273 * @param arg Custom (user) argument.
    270274 */
    271 static void usb_dp_browse_simple_internal(usb_dp_parser_t *parser,
    272     usb_dp_parser_data_t *data, uint8_t *root, size_t depth,
    273     void (*callback)(uint8_t *, size_t, void *), void *arg)
     275static void usb_dp_browse_simple_internal(const usb_dp_parser_t *parser,
     276    const usb_dp_parser_data_t *data, const uint8_t *root, size_t depth,
     277    void (*callback)(const uint8_t *, size_t, void *), void *arg)
    274278{
    275279        if (root == NULL) {
    … …  
    277281        }
    278282        callback(root, depth, arg);
    279         uint8_t *child = usb_dp_get_nested_descriptor(parser, data, root);
     283        const uint8_t *child = usb_dp_get_nested_descriptor(parser, data, root);
    280284        do {
    281285                usb_dp_browse_simple_internal(parser, data, child, depth + 1,
    … …  
    301305 */
    302306void usb_dp_walk_simple(uint8_t *descriptors, size_t descriptors_size,
    303     usb_dp_descriptor_nesting_t *descriptor_nesting,
    304     void (*callback)(uint8_t *, size_t, void *), void *arg)
     307    const usb_dp_descriptor_nesting_t *descriptor_nesting,
     308    walk_callback_t callback, void *arg)
    305309{
    306310        if ((descriptors == NULL) || (descriptors_size == 0)
    … …  
    309313        }
    310314
    311         usb_dp_parser_data_t data = {
     315        const usb_dp_parser_data_t data = {
    312316                .data = descriptors,
    313317                .size = descriptors_size,
    … …  
    315319        };
    316320
    317         usb_dp_parser_t parser = {
     321        const usb_dp_parser_t parser = {
    318322                .nesting = descriptor_nesting
    319323        };

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

    r4c3ad56 r20a3465  
    6868 * @return Whether the given descriptor is endpoint descriptor.
    6969 */
    70 static inline bool is_endpoint_descriptor(uint8_t *descriptor)
     70static inline bool is_endpoint_descriptor(const uint8_t *descriptor)
    7171{
    7272        return descriptor[1] == USB_DESCTYPE_ENDPOINT;
    … …  
    8080 */
    8181static bool endpoint_fits_description(const usb_endpoint_description_t *wanted,
    82     usb_endpoint_description_t *found)
     82    const usb_endpoint_description_t *found)
    8383{
    8484#define _SAME(fieldname) ((wanted->fieldname) == (found->fieldname))
    … …  
    120120static usb_endpoint_mapping_t *find_endpoint_mapping(
    121121    usb_endpoint_mapping_t *mapping, size_t mapping_count,
    122     usb_endpoint_description_t *found_endpoint,
     122    const usb_endpoint_description_t *found_endpoint,
    123123    int interface_number, int interface_setting)
    124124{
    … …  
    160160    usb_device_connection_t *wire)
    161161{
    162         usb_endpoint_description_t description;
    163162
    164163        /*
    … …  
    167166
    168167        /* Actual endpoint number is in bits 0..3 */
    169         usb_endpoint_t ep_no = endpoint->endpoint_address & 0x0F;
    170 
    171         /* Endpoint direction is set by bit 7 */
    172         description.direction = (endpoint->endpoint_address & 128)
    173             ? USB_DIRECTION_IN : USB_DIRECTION_OUT;
    174         /* Transfer type is in bits 0..2 and the enum values corresponds 1:1 */
    175         description.transfer_type = endpoint->attributes & 3;
    176 
    177         /*
    178          * Get interface characteristics.
    179          */
    180         description.interface_class = interface->interface_class;
    181         description.interface_subclass = interface->interface_subclass;
    182         description.interface_protocol = interface->interface_protocol;
     168        const usb_endpoint_t ep_no = endpoint->endpoint_address & 0x0F;
     169
     170        const usb_endpoint_description_t description = {
     171                /* Endpoint direction is set by bit 7 */
     172                .direction = (endpoint->endpoint_address & 128)
     173                    ? USB_DIRECTION_IN : USB_DIRECTION_OUT,
     174                /* Transfer type is in bits 0..2 and
     175                 * the enum values corresponds 1:1 */
     176                .transfer_type = endpoint->attributes & 3,
     177
     178                /* Get interface characteristics. */
     179                .interface_class = interface->interface_class,
     180                .interface_subclass = interface->interface_subclass,
     181                .interface_protocol = interface->interface_protocol,
     182        };
    183183
    184184        /*
    … …  
    224224static int process_interface(
    225225    usb_endpoint_mapping_t *mapping, size_t mapping_count,
    226     usb_dp_parser_t *parser, usb_dp_parser_data_t *parser_data,
    227     uint8_t *interface_descriptor)
    228 {
    229         uint8_t *descriptor = usb_dp_get_nested_descriptor(parser,
     226    const usb_dp_parser_t *parser, const usb_dp_parser_data_t *parser_data,
     227    const uint8_t *interface_descriptor)
     228{
     229        const uint8_t *descriptor = usb_dp_get_nested_descriptor(parser,
    230230            parser_data, interface_descriptor);
    231231
    … …  
    284284int usb_pipe_initialize_from_configuration(
    285285    usb_endpoint_mapping_t *mapping, size_t mapping_count,
    286     uint8_t *configuration_descriptor, size_t configuration_descriptor_size,
     286    const uint8_t *config_descriptor, size_t config_descriptor_size,
    287287    usb_device_connection_t *connection)
    288288{
    289289        assert(connection);
    290290
    291         if (configuration_descriptor == NULL) {
     291        if (config_descriptor == NULL) {
    292292                return EBADMEM;
    293293        }
    294         if (configuration_descriptor_size
     294        if (config_descriptor_size
    295295            < sizeof(usb_standard_configuration_descriptor_t)) {
    296296                return ERANGE;
    … …  
    310310         * Prepare the descriptor parser.
    311311         */
    312         usb_dp_parser_t dp_parser = {
     312        const usb_dp_parser_t dp_parser = {
    313313                .nesting = descriptor_nesting
    314314        };
    315         usb_dp_parser_data_t dp_data = {
    316                 .data = configuration_descriptor,
    317                 .size = configuration_descriptor_size,
     315        const usb_dp_parser_data_t dp_data = {
     316                .data = config_descriptor,
     317                .size = config_descriptor_size,
    318318                .arg = connection
    319319        };
    … …  
    322322         * Iterate through all interfaces.
    323323         */
    324         uint8_t *interface = usb_dp_get_nested_descriptor(&dp_parser,
    325             &dp_data, configuration_descriptor);
     324        const uint8_t *interface = usb_dp_get_nested_descriptor(&dp_parser,
     325            &dp_data, config_descriptor);
    326326        if (interface == NULL) {
    327327                return ENOENT;
    … …  
    329329        do {
    330330                (void) process_interface(mapping, mapping_count,
    331                     &dp_parser, &dp_data,
    332                     interface);
     331                    &dp_parser, &dp_data, interface);
    333332                interface = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data,
    334                     configuration_descriptor, interface);
     333                    config_descriptor, interface);
    335334        } while (interface != NULL);
    336335
    … …  
    514513{
    515514        assert(pipe);
     515        assert(pipe->wire);
    516516        assert(hc_connection);
    517517       

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

    r4c3ad56 r20a3465  
    425425
    426426        /* Everything is okay, copy the descriptor. */
    427         memcpy(descriptor, &descriptor_tmp,
    428             sizeof(descriptor_tmp));
     427        memcpy(descriptor, &descriptor_tmp, sizeof(descriptor_tmp));
    429428
    430429        return EOK;
    … …  
    470469
    471470        /* Everything is okay, copy the descriptor. */
    472         memcpy(descriptor, &descriptor_tmp,
    473             sizeof(descriptor_tmp));
     471        memcpy(descriptor, &descriptor_tmp, sizeof(descriptor_tmp));
    474472
    475473        return EOK;
Note: See TracChangeset for help on using the changeset viewer.