Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/usb/src/request.c

    r4723444 rb84e114  
    3636#include <errno.h>
    3737#include <assert.h>
    38 #include <usb/debug.h>
    3938
    4039#define MAX_DATA_LENGTH ((size_t)(0xFFFF))
     
    210209 */
    211210int usb_request_get_descriptor(usb_endpoint_pipe_t *pipe,
    212     usb_request_type_t request_type, usb_request_recipient_t recipient,
     211    usb_request_type_t request_type,
    213212    uint8_t descriptor_type, uint8_t descriptor_index,
    214213    uint16_t language,
     
    225224
    226225        return usb_control_request_get(pipe,
    227             request_type, recipient,
     226            request_type, USB_REQUEST_RECIPIENT_DEVICE,
    228227            USB_DEVREQ_GET_DESCRIPTOR,
    229228            wValue, language,
     
    243242 */
    244243int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t * pipe,
    245     usb_request_type_t request_type, usb_request_recipient_t recipient,
     244    usb_request_type_t request_type,
    246245    uint8_t descriptor_type, uint8_t descriptor_index,
    247246    uint16_t language,
     
    259258        uint8_t tmp_buffer[1];
    260259        size_t bytes_transfered;
    261         rc = usb_request_get_descriptor(pipe, request_type, recipient,
     260        rc = usb_request_get_descriptor(pipe, request_type,
    262261            descriptor_type, descriptor_index, language,
    263262            &tmp_buffer, 1, &bytes_transfered);
     
    284283        }
    285284
    286         rc = usb_request_get_descriptor(pipe, request_type, recipient,
     285        rc = usb_request_get_descriptor(pipe, request_type,
    287286            descriptor_type, descriptor_index, language,
    288287            buffer, size, &bytes_transfered);
     
    321320        usb_standard_device_descriptor_t descriptor_tmp;
    322321        int rc = usb_request_get_descriptor(pipe,
    323             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    324             USB_DESCTYPE_DEVICE, 0, 0,
     322            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_DEVICE,
     323            0, 0,
    325324            &descriptor_tmp, sizeof(descriptor_tmp),
    326325            &actually_transferred);
     
    367366        usb_standard_configuration_descriptor_t descriptor_tmp;
    368367        int rc = usb_request_get_descriptor(pipe,
    369             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    370             USB_DESCTYPE_CONFIGURATION, index, 0,
     368            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_CONFIGURATION,
     369            index, 0,
    371370            &descriptor_tmp, sizeof(descriptor_tmp),
    372371            &actually_transferred);
     
    407406
    408407        return usb_request_get_descriptor(pipe,
    409             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    410             USB_DESCTYPE_CONFIGURATION, index, 0,
     408            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_CONFIGURATION,
     409            index, 0,
    411410            descriptor, descriptor_size, actual_size);
    412 }
    413 
    414 /** Retrieve full configuration descriptor, allocate space for it.
    415  *
    416  * The function takes care that full configuration descriptor is returned
    417  * (i.e. the function will fail when less data then descriptor.totalLength
    418  * is returned).
    419  *
    420  * @param[in] pipe Control endpoint pipe (session must be already started).
    421  * @param[in] index Configuration index.
    422  * @param[out] descriptor_ptr Where to store pointer to allocated buffer.
    423  * @param[out] descriptor_size Where to store the size of the descriptor.
    424  * @return Error code.
    425  */
    426 int usb_request_get_full_configuration_descriptor_alloc(
    427     usb_endpoint_pipe_t *pipe, int index,
    428     void **descriptor_ptr, size_t *descriptor_size)
    429 {
    430         int rc;
    431 
    432         if (descriptor_ptr == NULL) {
    433                 return EBADMEM;
    434         }
    435 
    436         usb_standard_configuration_descriptor_t bare_config;
    437         rc = usb_request_get_bare_configuration_descriptor(pipe, index,
    438             &bare_config);
    439         if (rc != EOK) {
    440                 return rc;
    441         }
    442 
    443         if (bare_config.descriptor_type != USB_DESCTYPE_CONFIGURATION) {
    444                 return ENOENT;
    445         }
    446         if (bare_config.total_length < sizeof(bare_config)) {
    447                 return ELIMIT;
    448         }
    449 
    450         void *buffer = malloc(bare_config.total_length);
    451         if (buffer == NULL) {
    452                 return ENOMEM;
    453         }
    454 
    455         size_t transferred = 0;
    456         rc = usb_request_get_full_configuration_descriptor(pipe, index,
    457             buffer, bare_config.total_length, &transferred);
    458         if (rc != EOK) {
    459                 free(buffer);
    460                 return rc;
    461         }
    462 
    463         if (transferred != bare_config.total_length) {
    464                 free(buffer);
    465                 return ELIMIT;
    466         }
    467 
    468         /* Everything looks okay, copy the pointers. */
    469 
    470         *descriptor_ptr = buffer;
    471 
    472         if (descriptor_size != NULL) {
    473                 *descriptor_size = bare_config.total_length;
    474         }
    475 
    476         return EOK;
    477411}
    478412
     
    518452        size_t string_descriptor_size = 0;
    519453        rc = usb_request_get_descriptor_alloc(pipe,
    520             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    521             USB_DESCTYPE_STRING, 0, 0,
     454            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING, 0, 0,
    522455            (void **) &string_descriptor, &string_descriptor_size);
    523456        if (rc != EOK) {
     
    569502 *
    570503 * @param[in] pipe Control endpoint pipe (session must be already started).
    571  * @param[in] index String index (in native endianess),
    572  *      first index has number 1 (index from descriptors can be used directly).
     504 * @param[in] index String index (in native endianess).
    573505 * @param[in] lang String language (in native endianess).
    574506 * @param[out] string_ptr Where to store allocated string in native encoding.
     
    581513                return EBADMEM;
    582514        }
    583         /*
    584          * Index is actually one byte value and zero index is used
    585          * to retrieve list of supported languages.
    586          */
    587         if ((index < 1) || (index > 0xFF)) {
     515        /* Index is actually one byte value. */
     516        if (index > 0xFF) {
    588517                return ERANGE;
    589518        }
     
    602531        size_t string_size;
    603532        rc = usb_request_get_descriptor_alloc(pipe,
    604             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    605             USB_DESCTYPE_STRING, index, uint16_host2usb(lang),
     533            USB_REQUEST_TYPE_STANDARD, USB_DESCTYPE_STRING,
     534            index, uint16_host2usb(lang),
    606535            (void **) &string, &string_size);
    607536        if (rc != EOK) {
Note: See TracChangeset for help on using the changeset viewer.