Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1cf26ab r58563585  
    3434 */
    3535#include <usb/dev/request.h>
     36#include <usb/request.h>
     37#include <usb/usb.h>
     38
    3639#include <errno.h>
    37 #include <assert.h>
    38 #include <usb/debug.h>
     40#include <mem.h>
     41#include <stdlib.h>
     42#include <str.h>
    3943
    4044#define MAX_DATA_LENGTH ((size_t)(0xFFFF))
    … …  
    4650 * @see usb_pipe_control_write
    4751 *
    48  * @param pipe Pipe used for the communication.
     52 * @param pipe         Pipe used for the communication.
    4953 * @param request_type Request type (standard/class/vendor).
    50  * @param recipient Request recipient (e.g. device or endpoint).
    51  * @param request Actual request (e.g. GET_DESCRIPTOR).
    52  * @param value Value of @c wValue field of setup packet
    53  *      (must be in USB endianness).
    54  * @param index Value of @c wIndex field of setup packet
    55  *      (must be in USB endianness).
    56  * @param data Data to be sent during DATA stage
    57  *      (expected to be in USB endianness).
    58  * @param data_size Size of the @p data buffer (in native endianness).
     54 * @param recipient    Request recipient (e.g. device or endpoint).
     55 * @param request      Actual request (e.g. GET_DESCRIPTOR).
     56 * @param value        Value of @c wValue field of setup packet
     57 *                     (must be in USB endianness).
     58 * @param index        Value of @c wIndex field of setup packet
     59 *                     (must be in USB endianness).
     60 * @param data         Data to be sent during DATA stage
     61 *                     (expected to be in USB endianness).
     62 * @param data_size     Size of the @p data buffer (in native endianness).
     63 *
    5964 * @return Error code.
    6065 * @retval EBADMEM @p pipe is NULL.
    6166 * @retval EBADMEM @p data is NULL and @p data_size is not zero.
    6267 * @retval ERANGE Data buffer too large.
     68 *
    6369 */
    6470int usb_control_request_set(usb_pipe_t *pipe,
    6571    usb_request_type_t request_type, usb_request_recipient_t recipient,
    66     uint8_t request,
    67     uint16_t value, uint16_t index,
    68     void *data, size_t data_size)
     72    uint8_t request, uint16_t value, uint16_t index,
     73    const void *data, size_t data_size)
    6974{
    7075        if (pipe == NULL) {
    … …  
    8590         */
    8691
    87         usb_device_request_setup_packet_t setup_packet;
    88         setup_packet.request_type = (request_type << 5) | recipient;
    89         setup_packet.request = request;
    90         setup_packet.value = value;
    91         setup_packet.index = index;
    92         setup_packet.length = (uint16_t) data_size;
    93 
    94         int rc = usb_pipe_control_write(pipe,
    95             &setup_packet, sizeof(setup_packet),
    96             data, data_size);
    97 
    98         return rc;
    99 }
    100 
    101  /** Generic wrapper for GET requests using standard control request format.
    102   *
    103   * @see usb_pipe_control_read
    104   *
    105   * @param pipe Pipe used for the communication.
    106   * @param request_type Request type (standard/class/vendor).
    107   * @param recipient Request recipient (e.g. device or endpoint).
    108   * @param request Actual request (e.g. GET_DESCRIPTOR).
    109   * @param value Value of @c wValue field of setup packet
    110   *     (must be in USB endianness).
    111   * @param index Value of @c wIndex field of setup packet
    112   *     (must be in USB endianness).
    113   * @param data Buffer where to store data accepted during the DATA stage.
    114   *     (they will come in USB endianness).
    115   * @param data_size Size of the @p data buffer
    116   *     (in native endianness).
    117   * @param actual_data_size Actual size of transfered data
    118   *        (in native endianness).
    119   * @return Error code.
    120   * @retval EBADMEM @p pipe is NULL.
    121   * @retval EBADMEM @p data is NULL and @p data_size is not zero.
    122   * @retval ERANGE Data buffer too large.
    123   */
     92        const usb_device_request_setup_packet_t setup_packet = {
     93                .request_type = (request_type << 5) | recipient,
     94                .request = request,
     95                .value = value,
     96                .index = index,
     97                .length = (uint16_t) data_size,
     98        };
     99
     100        return usb_pipe_control_write(pipe,
     101            &setup_packet, sizeof(setup_packet), data, data_size);
     102}
     103
     104/** Generic wrapper for GET requests using standard control request format.
     105 *
     106 * @see usb_pipe_control_read
     107 *
     108 * @param pipe             Pipe used for the communication.
     109 * @param request_type     Request type (standard/class/vendor).
     110 * @param recipient        Request recipient (e.g. device or endpoint).
     111 * @param request          Actual request (e.g. GET_DESCRIPTOR).
     112 * @param value            Value of @c wValue field of setup packet
     113 *                         (must be in USB endianness).
     114 * @param index            Value of @c wIndex field of setup packet
     115 *                         (must be in USB endianness).
     116 * @param data             Buffer where to store data accepted during
     117 *                         the DATA stage (they will come in USB endianness).
     118 * @param data_size        Size of the @p data buffer
     119 *                         (in native endianness).
     120 * @param actual_data_size Actual size of transfered data
     121 *                         (in native endianness).
     122 *
     123 * @return Error code.
     124 * @retval EBADMEM @p pipe is NULL.
     125 * @retval EBADMEM @p data is NULL and @p data_size is not zero.
     126 * @retval ERANGE Data buffer too large.
     127 *
     128 */
    124129int usb_control_request_get(usb_pipe_t *pipe,
    125130    usb_request_type_t request_type, usb_request_recipient_t recipient,
    126     uint8_t request,
    127     uint16_t value, uint16_t index,
     131    uint8_t request, uint16_t value, uint16_t index,
    128132    void *data, size_t data_size, size_t *actual_data_size)
    129133{
    … …  
    209213{
    210214        if (request_type == USB_REQUEST_TYPE_STANDARD) {
    211                 if ((recipient == USB_REQUEST_RECIPIENT_DEVICE)
    212                     && (index != 0)) {
     215                if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) && (index != 0)) {
    213216                        return EINVAL;
    214217                }
    215218        }
    216219
    217         int rc = usb_control_request_set(pipe, request_type, recipient,
    218             USB_DEVREQ_CLEAR_FEATURE,
    219             uint16_host2usb(feature_selector), uint16_host2usb(index),
    220             NULL, 0);
    221 
    222         return rc;
     220        return usb_control_request_set(pipe,
     221            request_type, recipient, USB_DEVREQ_CLEAR_FEATURE,
     222            uint16_host2usb(feature_selector), uint16_host2usb(index), NULL, 0);
    223223}
    224224
    … …  
    237237{
    238238        if (request_type == USB_REQUEST_TYPE_STANDARD) {
    239                 if ((recipient == USB_REQUEST_RECIPIENT_DEVICE)
    240                     && (index != 0)) {
     239                if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) && (index != 0)) {
    241240                        return EINVAL;
    242241                }
    243242        }
    244243
    245         int rc = usb_control_request_set(pipe, request_type, recipient,
    246             USB_DEVREQ_SET_FEATURE,
    247             uint16_host2usb(feature_selector), uint16_host2usb(index),
    248             NULL, 0);
    249 
    250         return rc;
     244        return usb_control_request_set(pipe,
     245            request_type, recipient, USB_DEVREQ_SET_FEATURE,
     246            uint16_host2usb(feature_selector), uint16_host2usb(index), NULL, 0);
    251247}
    252248
    … …  
    277273        }
    278274
     275        /*
     276         * The wValue field specifies the descriptor type in the high byte
     277         * and the descriptor index in the low byte. USB 1.1 spec p. 189
     278         */
    279279        const uint16_t wValue = descriptor_index | (descriptor_type << 8);
    280280
    … …  
    313313         * Get only first byte to retrieve descriptor length.
    314314         */
    315         uint8_t tmp_buffer[1];
     315        uint8_t tmp_buffer;
    316316        size_t bytes_transfered;
    317317        rc = usb_request_get_descriptor(pipe, request_type, recipient,
    318318            descriptor_type, descriptor_index, language,
    319             &tmp_buffer, 1, &bytes_transfered);
     319            &tmp_buffer, sizeof(tmp_buffer), &bytes_transfered);
    320320        if (rc != EOK) {
    321321                return rc;
    322322        }
    323323        if (bytes_transfered != 1) {
    324                 /* FIXME: some better error code? */
    325                 return ESTALL;
    326         }
    327 
    328         size_t size = tmp_buffer[0];
     324                return ELIMIT;
     325        }
     326
     327        const size_t size = tmp_buffer;
    329328        if (size == 0) {
    330                 /* FIXME: some better error code? */
    331                 return ESTALL;
     329                return ELIMIT;
    332330        }
    333331
    … …  
    349347        if (bytes_transfered != size) {
    350348                free(buffer);
    351                 /* FIXME: some better error code? */
    352                 return ESTALL;
     349                return ELIMIT;
    353350        }
    354351
    … …  
    378375        int rc = usb_request_get_descriptor(pipe,
    379376            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    380             USB_DESCTYPE_DEVICE, 0, 0,
    381             &descriptor_tmp, sizeof(descriptor_tmp),
     377            USB_DESCTYPE_DEVICE, 0, 0, &descriptor_tmp, sizeof(descriptor_tmp),
    382378            &actually_transferred);
    383379
    … …  
    421417        size_t actually_transferred = 0;
    422418        usb_standard_configuration_descriptor_t descriptor_tmp;
    423         int rc = usb_request_get_descriptor(pipe,
     419        const int rc = usb_request_get_descriptor(pipe,
    424420            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    425421            USB_DESCTYPE_CONFIGURATION, index, 0,
    … …  
    479475int usb_request_get_full_configuration_descriptor_alloc(
    480476    usb_pipe_t *pipe, int index,
    481     void **descriptor_ptr, size_t *descriptor_size)
     477    const void **descriptor_ptr, size_t *descriptor_size)
    482478{
    483479        int rc;
    … …  
    546542    usb_request_type_t request_type, usb_request_recipient_t recipient,
    547543    uint8_t descriptor_type, uint8_t descriptor_index,
    548     uint16_t language,
    549     void *buffer, size_t size)
     544    uint16_t language, const void *buffer, size_t size)
    550545{
    551546        if (buffer == NULL) {
    … …  
    560555
    561556        return usb_control_request_set(pipe,
    562             request_type, recipient,
    563             USB_DEVREQ_SET_DESCRIPTOR,
    564             wValue, language,
    565             buffer, size);
     557            request_type, recipient, USB_DEVREQ_SET_DESCRIPTOR,
     558            wValue, language, buffer, size);
    566559}
    567560
    … …  
    578571        size_t actual_size;
    579572
    580         int rc = usb_control_request_get(pipe,
     573        const int rc = usb_control_request_get(pipe,
    581574            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    582             USB_DEVREQ_GET_CONFIGURATION,
    583             0, 0,
    584             &value, 1, &actual_size);
     575            USB_DEVREQ_GET_CONFIGURATION, 0, 0, &value, 1, &actual_size);
    585576
    586577        if (rc != EOK) {
    … …  
    607598    uint8_t configuration_value)
    608599{
    609         uint16_t config_value
     600        const uint16_t config_value
    610601            = uint16_host2usb((uint16_t) configuration_value);
    611602
    … …  
    629620        size_t actual_size;
    630621
    631         int rc = usb_control_request_get(pipe,
     622        const int rc = usb_control_request_get(pipe,
    632623            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE,
    633624            USB_DEVREQ_GET_INTERFACE,
    634625            0, uint16_host2usb((uint16_t) interface_index),
    635             &value, 1, &actual_size);
     626            &value, sizeof(value), &actual_size);
    636627
    637628        if (rc != EOK) {
    … …  
    678669    l18_win_locales_t **languages_ptr, size_t *languages_count)
    679670{
    680         int rc;
    681 
    682         if (languages_ptr == NULL) {
    683                 return EBADMEM;
    684         }
    685         if (languages_count == NULL) {
     671        if (languages_ptr == NULL || languages_count == NULL) {
    686672                return EBADMEM;
    687673        }
    … …  
    689675        uint8_t *string_descriptor = NULL;
    690676        size_t string_descriptor_size = 0;
    691         rc = usb_request_get_descriptor_alloc(pipe,
     677        const int rc = usb_request_get_descriptor_alloc(pipe,
    692678            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    693679            USB_DESCTYPE_STRING, 0, 0,
    … …  
    710696        }
    711697
    712         size_t langs_count = string_descriptor_size / 2;
    713         l18_win_locales_t *langs
    714             = malloc(sizeof(l18_win_locales_t) * langs_count);
     698        const size_t langs_count = string_descriptor_size / 2;
     699        l18_win_locales_t *langs =
     700            calloc(langs_count, sizeof(l18_win_locales_t));
    715701        if (langs == NULL) {
    716702                free(string_descriptor);
    … …  
    718704        }
    719705
    720         size_t i;
    721         for (i = 0; i < langs_count; i++) {
     706        for (size_t i = 0; i < langs_count; i++) {
    722707                /* Language code from the descriptor is in USB endianness. */
    723708                /* FIXME: is this really correct? */
    724                 uint16_t lang_code = (string_descriptor[2 + 2 * i + 1] << 8)
     709                const uint16_t lang_code =
     710                    (string_descriptor[2 + 2 * i + 1] << 8)
    725711                    + string_descriptor[2 + 2 * i];
    726712                langs[i] = uint16_usb2host(lang_code);
    … …  
    761747        }
    762748        /* Language is actually two byte value. */
    763         if (lang > 0xFFFF) {
     749        if (lang > L18N_WIN_LOCALE_MAX) {
    764750                return ERANGE;
    765751        }
    … …  
    795781        }
    796782
    797         size_t string_char_count = string_size / 2;
     783        const size_t string_char_count = string_size / 2;
    798784        string_chars = malloc(sizeof(wchar_t) * (string_char_count + 1));
    799785        if (string_chars == NULL) {
    … …  
    807793         * do not have them).
    808794         */
    809         size_t i;
    810         for (i = 0; i < string_char_count; i++) {
    811                 uint16_t uni_char = (string[2 + 2 * i + 1] << 8)
     795        for (size_t i = 0; i < string_char_count; i++) {
     796                const uint16_t uni_char = (string[2 + 2 * i + 1] << 8)
    812797                    + string[2 + 2 * i];
    813798                string_chars[i] = uni_char;
    … …  
    827812
    828813leave:
    829         if (string != NULL) {
    830                 free(string);
    831         }
    832         if (string_chars != NULL) {
    833                 free(string_chars);
    834         }
     814        free(string);
     815        free(string_chars);
    835816
    836817        return rc;
    … …  
    847828        return usb_request_clear_feature(pipe,
    848829            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_ENDPOINT,
    849             uint16_host2usb(USB_FEATURE_SELECTOR_ENDPOINT_HALT),
     830            uint16_host2usb(USB_FEATURE_ENDPOINT_HALT),
    850831            uint16_host2usb(ep_index));
    851832}
Note: See TracChangeset for help on using the changeset viewer.