Changes in / [a97ea0f:a523af4] in mainline


Ignore:
Location:
uspace
Files:
1 deleted
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/usbinfo/Makefile

    ra97ea0f ra523af4  
    3535SOURCES = \
    3636        dump.c \
    37         info.c \
    3837        main.c
    3938

  • uspace/app/usbinfo/main.c

    ra97ea0f ra523af4  
    11/*
    2  * Copyright (c) 2010-2011 Vojtech Horky
     2 * Copyright (c) 2010 Vojtech Horky
    33 * All rights reserved.
    44 *
    … …  
    4040#include <str_error.h>
    4141#include <bool.h>
    42 #include <getopt.h>
    4342#include <devman.h>
    44 #include <devmap.h>
    4543#include <usb/usbdrv.h>
    4644#include "usbinfo.h"
    4745
    48 enum {
    49         ACTION_HELP = 256,
    50         ACTION_DEVICE_ADDRESS,
    51         ACTION_HOST_CONTROLLER,
    52         ACTION_DEVICE,
    53 };
    54 
    55 static struct option long_options[] = {
    56         {"help", no_argument, NULL, ACTION_HELP},
    57         {"address", required_argument, NULL, ACTION_DEVICE_ADDRESS},
    58         {"host-controller", required_argument, NULL, ACTION_HOST_CONTROLLER},
    59         {"device", required_argument, NULL, ACTION_DEVICE},
    60         {0, 0, NULL, 0}
    61 };
    62 static const char *short_options = "ha:t:d:";
     46#define DEFAULT_HOST_CONTROLLER_PATH "/virt/usbhc"
    6347
    6448static void print_usage(char *app_name)
    6549{
    66 #define INDENT "      "
    6750        printf(NAME ": query USB devices for descriptors\n\n");
    68         printf("Usage: %s [options]\n", app_name);
    69         printf(" -h --help\n" INDENT \
    70             "Display this help.\n");
    71         printf(" -tID --host-controller ID\n" INDENT \
    72             "Set host controller (ID can be path or class number)\n");
    73         printf(" -aADDR --address ADDR\n" INDENT \
    74             "Set device address\n");
     51        printf("Usage: %s /path/to/hc usb-address\n where\n", app_name);
     52        printf("   /path/to/hc   Devman path to USB host controller " \
     53            "(use `-' for\n");
     54        printf("                   default HC at `%s').\n",
     55            DEFAULT_HOST_CONTROLLER_PATH);
     56        printf("   usb-address   USB address of device to be queried\n");
    7557        printf("\n");
    76 #undef INDENT
    7758}
    7859
    79 static int set_new_host_controller(int *phone, const char *path)
     60static int connect_to_hc(const char *path)
    8061{
    8162        int rc;
    82         int tmp_phone;
     63        devman_handle_t handle;
    8364
    84         if (path[0] != '/') {
    85                 int hc_class_index = (int) strtol(path, NULL, 10);
    86                 char *dev_path;
    87                 rc = asprintf(&dev_path, "class/usbhc\\%d", hc_class_index);
    88                 if (rc < 0) {
    89                         internal_error(rc);
    90                         return rc;
    91                 }
    92                 devmap_handle_t handle;
    93                 rc = devmap_device_get_handle(dev_path, &handle, 0);
    94                 if (rc < 0) {
    95                         fprintf(stderr,
    96                             NAME ": failed getting handle of `devman://%s'.\n",
    97                             dev_path);
    98                         free(dev_path);
    99                         return rc;
    100                 }
    101                 tmp_phone = devmap_device_connect(handle, 0);
    102                 if (tmp_phone < 0) {
    103                         fprintf(stderr,
    104                             NAME ": could not connect to `%s'.\n",
    105                             dev_path);
    106                         free(dev_path);
    107                         return tmp_phone;
    108                 }
    109                 free(dev_path);
    110         } else {
    111                 devman_handle_t handle;
    112                 rc = devman_device_get_handle(path, &handle, 0);
    113                 if (rc != EOK) {
    114                         fprintf(stderr,
    115                             NAME ": failed getting handle of `devmap::/%s'.\n",
    116                             path);
    117                         return rc;
    118                 }
    119                 tmp_phone = devman_device_connect(handle, 0);
    120                 if (tmp_phone < 0) {
    121                         fprintf(stderr,
    122                             NAME ": could not connect to `%s'.\n",
    123                             path);
    124                         return tmp_phone;
    125                 }
     65        rc = devman_device_get_handle(path, &handle, 0);
     66        if (rc != EOK) {
     67                return rc;
    12668        }
    12769
    128         *phone = tmp_phone;
     70        int phone = devman_device_connect(handle, 0);
    12971
    130         return EOK;
     72        return phone;
    13173}
    13274
    133 static int connect_with_address(int hc_phone, const char *str_address)
     75int main(int argc, char *argv[])
    13476{
    135         usb_address_t address = (usb_address_t) strtol(str_address, NULL, 0);
     77        if (argc != 3) {
     78                print_usage(argv[0]);
     79                return EINVAL;
     80        }
     81
     82        char *hc_path = argv[1];
     83        long int address_long = strtol(argv[2], NULL, 0);
     84
     85        /*
     86         * Connect to given host controller driver.
     87         */
     88        if (str_cmp(hc_path, "-") == 0) {
     89                hc_path = (char *) DEFAULT_HOST_CONTROLLER_PATH;
     90        }
     91        int hc_phone = connect_to_hc(hc_path);
     92        if (hc_phone < 0) {
     93                fprintf(stderr,
     94                    NAME ": unable to connect to HC at `%s': %s.\n",
     95                    hc_path, str_error(hc_phone));
     96                return hc_phone;
     97        }
     98
     99        /*
     100         * Verify address is okay.
     101         */
     102        usb_address_t address = (usb_address_t) address_long;
    136103        if ((address < 0) || (address >= USB11_ADDRESS_MAX)) {
    137104                fprintf(stderr, NAME ": USB address out of range.\n");
    … …  
    139106        }
    140107
    141         if (hc_phone < 0) {
    142                 fprintf(stderr, NAME ": no active host controller.\n");
    143                 return ENOENT;
     108        /*
     109         * Now, learn information about the device.
     110         */
     111        int rc;
     112
     113        /*
     114         * Dump information about possible match ids.
     115         */
     116        match_id_list_t match_id_list;
     117        init_match_ids(&match_id_list);
     118        rc = usb_drv_create_device_match_ids(hc_phone, &match_id_list, address);
     119        if (rc != EOK) {
     120                fprintf(stderr,
     121                    NAME ": failed to fetch match ids of the device: %s.\n",
     122                    str_error(rc));
     123                return rc;
    144124        }
     125        dump_match_ids(&match_id_list);
    145126
    146         return dump_device(hc_phone, address);
    147 }
     127        /*
     128         * Get device descriptor and dump it.
     129         */
     130        usb_standard_device_descriptor_t device_descriptor;
     131        usb_dprintf(NAME, 1,
     132            "usb_drv_req_get_device_descriptor(%d, %d, %p)\n",
     133            hc_phone, (int) address, &device_descriptor);
    148134
     135        rc = usb_drv_req_get_device_descriptor(hc_phone, address,
     136            &device_descriptor);
     137        if (rc != EOK) {
     138                fprintf(stderr,
     139                    NAME ": failed to fetch standard device descriptor: %s.\n",
     140                    str_error(rc));
     141                return rc;
     142        }
     143        dump_standard_device_descriptor(&device_descriptor);
    149144
    150 int main(int argc, char *argv[])
    151 {
    152         int hc_phone = -1;
     145        /*
     146         * Get first configuration descriptor and dump it.
     147         */
     148        usb_standard_configuration_descriptor_t config_descriptor;
     149        int config_index = 0;
     150        usb_dprintf(NAME, 1,
     151            "usb_drv_req_get_bare_configuration_descriptor(%d, %d, %d, %p)\n",
     152            hc_phone, (int) address, config_index, &config_descriptor);
    153153
    154         if (argc <= 1) {
    155                 print_usage(argv[0]);
    156                 return -1;
     154        rc = usb_drv_req_get_bare_configuration_descriptor(hc_phone, address,
     155            config_index, &config_descriptor );
     156        if (rc != EOK) {
     157                fprintf(stderr,
     158                    NAME ": failed to fetch standard configuration descriptor: %s.\n",
     159                    str_error(rc));
     160                return rc;
    157161        }
     162        dump_standard_configuration_descriptor(config_index,
     163            &config_descriptor);
    158164
    159         int i;
    160         do {
    161                 i = getopt_long(argc, argv, short_options, long_options, NULL);
    162                 switch (i) {
    163                         case -1:
    164                                 break;
     165        void *full_config_descriptor = malloc(config_descriptor.total_length);
     166        usb_dprintf(NAME, 1,
     167            "usb_drv_req_get_full_configuration_descriptor(%d, %d, %d, %p, %zu)\n",
     168            hc_phone, (int) address, config_index,
     169            full_config_descriptor, config_descriptor.total_length);
    165170
    166                         case '?':
    167                                 print_usage(argv[0]);
    168                                 return -1;
     171        rc = usb_drv_req_get_full_configuration_descriptor(hc_phone, address,
     172            config_index,
     173            full_config_descriptor, config_descriptor.total_length, NULL);
     174        if (rc != EOK) {
     175                fprintf(stderr,
     176                    NAME ": failed to fetch full configuration descriptor: %s.\n",
     177                    str_error(rc));
     178                return rc;
     179        }
     180        dump_buffer("Full configuration descriptor:",
     181            full_config_descriptor, config_descriptor.total_length);
    169182
    170                         case 'h':
    171                         case ACTION_HELP:
    172                                 print_usage(argv[0]);
    173                                 return 0;
    174 
    175                         case 'a':
    176                         case ACTION_DEVICE_ADDRESS: {
    177                                 int rc = connect_with_address(hc_phone, optarg);
    178                                 if (rc != EOK) {
    179                                         return rc;
    180                                 }
    181                                 break;
    182                         }
    183 
    184                         case 't':
    185                         case ACTION_HOST_CONTROLLER: {
    186                                 int rc = set_new_host_controller(&hc_phone,
    187                                     optarg);
    188                                 if (rc != EOK) {
    189                                         return rc;
    190                                 }
    191                                 break;
    192                         }
    193 
    194                         case 'd':
    195                         case ACTION_DEVICE:
    196                                 break;
    197 
    198                         default:
    199                                 break;
    200                 }
    201 
    202         } while (i != -1);
    203 
    204         return 0;
     183        return EOK;
    205184}
    206185

  • uspace/app/usbinfo/usbinfo.h

    ra97ea0f ra523af4  
    4949void dump_standard_configuration_descriptor(int,
    5050    usb_standard_configuration_descriptor_t *);
    51 int dump_device(int, usb_address_t);
    52 
    53 static inline void internal_error(int err)
    54 {
    55         fprintf(stderr, NAME ": internal error (%s).\n", str_error(err));
    56 }
    5751
    5852#endif

  • uspace/drv/usbkbd/main.c

    ra97ea0f ra523af4  
    7878}
    7979
    80 #if 0
    8180static void send_key(int key, int type, wchar_t c) {
    8281        async_msg_4(console_callback_phone, KBD_EVENT, type, key,
    8382            KM_NUM_LOCK, c);
    8483}
    85 #endif
     84
     85static void send_alnum(int key, wchar_t c) {
     86        printf(NAME ": sending key '%lc' to console\n", (wint_t) c);
     87        send_key(key, KEY_PRESS, c);
     88        send_key(key, KEY_RELEASE, c);
     89}
    8690
    8791/*
    … …  
    227231                sizeof(usb_hid_report_in_callbacks_t));
    228232        callbacks->keyboard = usbkbd_process_keycodes;
     233
     234        if (console_callback_phone != -1) {
     235                static size_t counter = 0;
     236                counter++;
     237                if (counter > 3) {
     238                        counter = 0;
     239                        send_alnum(KC_A, L'a');
     240                }
     241        }
    229242
    230243        usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, callbacks,

  • uspace/drv/vhc/hcd.c

    ra97ea0f ra523af4  
    8686        dev->ops = &vhc_ops;
    8787
    88         devman_add_device_to_class(dev->handle, "usbhc");
    89 
    9088        /*
    9189         * Initialize our hub and announce its presence.

  • uspace/lib/usb/include/usb/devreq.h

    ra97ea0f ra523af4  
    8585} __attribute__ ((packed)) usb_device_request_setup_packet_t;
    8686
    87 
    88 int usb_drv_req_get_status(int, usb_address_t, usb_request_recipient_t,
    89     uint16_t, uint16_t *);
    90 int usb_drv_req_clear_feature(int, usb_address_t, usb_request_recipient_t,
    91     uint16_t, uint16_t);
    92 int usb_drv_req_set_feature(int, usb_address_t, usb_request_recipient_t,
    93     uint16_t, uint16_t);
    9487int usb_drv_req_set_address(int, usb_address_t, usb_address_t);
    95 int usb_drv_req_get_descriptor(int, usb_address_t, usb_request_type_t,
    96     uint8_t, uint8_t, uint16_t, void *, size_t, size_t *);
    9788int usb_drv_req_get_device_descriptor(int, usb_address_t,
    9889    usb_standard_device_descriptor_t *);
    … …  
    10192int usb_drv_req_get_full_configuration_descriptor(int, usb_address_t, int,
    10293    void *, size_t, size_t *);
    103 int usb_drv_req_set_descriptor(int, usb_address_t, uint8_t, uint8_t, uint16_t,
    104     void *, size_t);
    105 int usb_drv_req_get_configuration(int, usb_address_t, uint8_t *);
    106 int usb_drv_req_set_configuration(int, usb_address_t, uint8_t);
    107 int usb_drv_req_get_interface(int, usb_address_t, uint16_t, uint8_t *);
    108 int usb_drv_req_set_interface(int, usb_address_t, uint16_t, uint8_t);
     94int usb_drv_req_get_descriptor(int, usb_address_t, usb_request_type_t,
     95    uint8_t, uint8_t, uint16_t, void *, size_t, size_t *);
     96
    10997
    11098#endif

  • uspace/lib/usb/include/usb/usb.h

    ra97ea0f ra523af4  
    6161        USB_REQUEST_TYPE_VENDOR = 2
    6262} usb_request_type_t;
    63 
    64 /** USB request recipient. */
    65 typedef enum {
    66         USB_REQUEST_RECIPIENT_DEVICE = 0,
    67         USB_REQUEST_RECIPIENT_INTERFACE = 1,
    68         USB_REQUEST_RECIPIENT_ENDPOINT = 2
    69 } usb_request_recipient_t;
    7063
    7164/** USB transaction outcome. */

  • uspace/lib/usb/src/usbdrvreq.c

    ra97ea0f ra523af4  
    3636#include <errno.h>
    3737
    38 /**  Prepare USB target for control endpoint.
    39  *
    40  * @param name Variable name with the USB target.
    41  * @param target_address Target USB address.
    42  */
    43 #define PREPARE_TARGET(name, target_address) \
    44         usb_target_t name = { \
    45                 .address = target_address, \
    46                 .endpoint = 0 \
    47         }
    48 
    49 /** Prepare setup packet.
    50  *
    51  * @param name Variable name with the setup packet.
    52  * @param p_direction Data transfer direction.
    53  * @param p_type Request type (standard/class/vendor)
    54  * @param p_recipient Recipient of the request.
    55  * @param p_request Request.
    56  * @param p_value wValue field of setup packet.
    57  * @param p_index wIndex field of setup packet.
    58  * @param p_length Length of extra data.
    59  */
    60 #define PREPARE_SETUP_PACKET(name, p_direction, p_type, p_recipient, \
    61     p_request, p_value, p_index, p_length) \
    62         usb_device_request_setup_packet_t setup_packet = { \
    63                 .request_type = \
    64                         ((p_direction) == USB_DIRECTION_IN ? 128 : 0) \
    65                         | ((p_type) << 5) \
    66                         | (p_recipient), \
    67                 .request = (p_request), \
    68                 { .value = (p_value) }, \
    69                 .index = (p_index), \
    70                 .length = (p_length) \
    71         }
    72 
    73 /** Prepare setup packet.
    74  *
    75  * @param name Variable name with the setup packet.
    76  * @param p_direction Data transfer direction.
    77  * @param p_type Request type (standard/class/vendor)
    78  * @param p_recipient Recipient of the request.
    79  * @param p_request Request.
    80  * @param p_value_low wValue field of setup packet (low byte).
    81  * @param p_value_high wValue field of setup packet (high byte).
    82  * @param p_index wIndex field of setup packet.
    83  * @param p_length Length of extra data.
    84  */
    85 #define PREPARE_SETUP_PACKET_LOHI(name, p_direction, p_type, p_recipient, \
    86     p_request, p_value_low, p_value_high, p_index, p_length) \
    87         PREPARE_SETUP_PACKET(name, p_direction, p_type, p_recipient, \
    88             p_request, (p_value_low) | ((p_value_high) << 8), \
    89             p_index, p_length)
    90 
    91 /** Retrieve status of a USB device.
    92  *
    93  * @param[in] hc_phone Open phone to HC driver.
    94  * @param[in] address Device address.
    95  * @param[in] recipient Recipient of the request.
    96  * @param[in] recipient_index Index of @p recipient.
    97  * @param[out] status Status (see figure 9-4 in USB 1.1 specification).
    98  * @return Error code.
    99  */
    100 int usb_drv_req_get_status(int hc_phone, usb_address_t address,
    101     usb_request_recipient_t recipient, uint16_t recipient_index,
    102     uint16_t *status)
    103 {
    104         if (status == NULL) {
    105                 return EBADMEM;
    106         }
    107 
    108         PREPARE_TARGET(target, address);
    109 
    110         PREPARE_SETUP_PACKET(setup_packet,
    111             USB_DIRECTION_IN, USB_REQUEST_TYPE_STANDARD,
    112             recipient, USB_DEVREQ_GET_STATUS, 0, recipient_index, 2);
    113 
    114         size_t transfered;
    115         uint16_t tmp_status;
    116         int rc = usb_drv_psync_control_read(hc_phone, target,
    117             &setup_packet, sizeof(setup_packet), &tmp_status, 2, &transfered);
    118         if (rc != EOK) {
    119                 return rc;
    120         }
    121         if (transfered != 2) {
    122                 return ERANGE;
    123         }
    124 
    125         *status = tmp_status;
    126 
    127         return EOK;
    128 }
    129 
    130 /** Clear or disable USB device feature.
    131  *
    132  * @param[in] hc_phone Open phone to HC driver.
    133  * @param[in] address Device address.
    134  * @param[in] recipient Recipient of the request.
    135  * @param[in] selector Feature selector.
    136  * @param[in] index Index of @p recipient.
    137  * @return Error code.
    138  */
    139 int usb_drv_req_clear_feature(int hc_phone, usb_address_t address,
    140     usb_request_recipient_t recipient,
    141     uint16_t selector, uint16_t index)
    142 {
    143         PREPARE_TARGET(target, address);
    144 
    145         PREPARE_SETUP_PACKET(setup_packet,
    146             USB_DIRECTION_OUT, USB_REQUEST_TYPE_STANDARD,
    147             recipient, USB_DEVREQ_CLEAR_FEATURE, selector, index, 0);
    148 
    149         int rc = usb_drv_psync_control_write(hc_phone, target,
    150             &setup_packet, sizeof(setup_packet), NULL, 0);
    151 
    152         return rc;
    153 }
    154 
    155 /** Set or enable USB device feature.
    156  *
    157  * @param[in] hc_phone Open phone to HC driver.
    158  * @param[in] address Device address.
    159  * @param[in] recipient Recipient of the request.
    160  * @param[in] selector Feature selector.
    161  * @param[in] index Index of @p recipient.
    162  * @return Error code.
    163  */
    164 int usb_drv_req_set_feature(int hc_phone, usb_address_t address,
    165     usb_request_recipient_t recipient,
    166     uint16_t selector, uint16_t index)
    167 {
    168         PREPARE_TARGET(target, address);
    169 
    170         PREPARE_SETUP_PACKET(setup_packet,
    171             USB_DIRECTION_OUT, USB_REQUEST_TYPE_STANDARD,
    172             recipient, USB_DEVREQ_SET_FEATURE, selector, index, 0);
    173 
    174         int rc = usb_drv_psync_control_write(hc_phone, target,
    175             &setup_packet, sizeof(setup_packet), NULL, 0);
    176 
    177         return rc;
    178 }
    179 
    18038/** Change address of connected device.
    18139 *
    … …  
    18644 * @see usb_drv_bind_address
    18745 *
    188  * @param[in] phone Open phone to HC driver.
    189  * @param[in] old_address Current address.
    190  * @param[in] address Address to be set.
     46 * @param phone Open phone to HC driver.
     47 * @param old_address Current address.
     48 * @param address Address to be set.
    19149 * @return Error code.
    19250 */
    … …  
    19452    usb_address_t new_address)
    19553{
    196         PREPARE_TARGET(target, old_address);
    197 
    198         PREPARE_SETUP_PACKET(setup_packet, USB_DIRECTION_OUT,
    199             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    200             USB_DEVREQ_SET_ADDRESS, new_address, 0, 0);
     54        /* Prepare the target. */
     55        usb_target_t target = {
     56                .address = old_address,
     57                .endpoint = 0
     58        };
     59
     60        /* Prepare the setup packet. */
     61        usb_device_request_setup_packet_t setup_packet = {
     62                .request_type = 0,
     63                .request = USB_DEVREQ_SET_ADDRESS,
     64                .index = 0,
     65                .length = 0,
     66        };
     67        setup_packet.value = new_address;
    20168
    20269        int rc = usb_drv_psync_control_write(phone, target,
    … …  
    20976 *
    21077 * @param[in] hc_phone Open phone to HC driver.
    211  * @param[in] address Device address.
     78 * @param[in] address Device USB address.
    21279 * @param[in] request_type Request type (standard/class/vendor).
    21380 * @param[in] descriptor_type Descriptor type (device/configuration/HID/...).
    21481 * @param[in] descriptor_index Descriptor index.
    215  * @param[in] language Language index.
     82 * @param[in] langauge Language index.
    21683 * @param[out] buffer Buffer where to store the retrieved descriptor.
    21784 * @param[in] size Size of the @p buffer.
    … …  
    22592    void *buffer, size_t size, size_t *actual_size)
    22693{
    227         if (buffer == NULL) {
    228                 return EBADMEM;
    229         }
    230         if (size == 0) {
    231                 return EINVAL;
    232         }
    233 
    234         // FIXME: check that size is not too big
    235 
    236         PREPARE_TARGET(target, address);
    237 
    238         PREPARE_SETUP_PACKET_LOHI(setup_packet, USB_DIRECTION_IN,
    239             request_type, USB_REQUEST_RECIPIENT_DEVICE,
    240             USB_DEVREQ_GET_DESCRIPTOR, descriptor_index, descriptor_type,
    241             language, size);
    242 
     94        /* Prepare the target. */
     95        usb_target_t target = {
     96                .address = address,
     97                .endpoint = 0
     98        };
     99
     100        /* Prepare the setup packet. */
     101        usb_device_request_setup_packet_t setup_packet = {
     102                .request_type = 128 | (request_type << 5),
     103                .request = USB_DEVREQ_GET_DESCRIPTOR,
     104                .index = language,
     105                .length = (uint16_t) size,
     106        };
     107        setup_packet.value_high = descriptor_type;
     108        setup_packet.value_low = descriptor_index;
     109       
     110        /* Perform CONTROL READ */
    243111        int rc = usb_drv_psync_control_read(hc_phone, target,
    244112            &setup_packet, sizeof(setup_packet),
    … …  
    251119 *
    252120 * @param[in] phone Open phone to HC driver.
    253  * @param[in] address Device address.
     121 * @param[in] address Device USB address.
    254122 * @param[out] descriptor Storage for the device descriptor.
    255123 * @return Error code.
    … …  
    296164 *
    297165 * @param[in] phone Open phone to HC driver.
    298  * @param[in] address Device address.
     166 * @param[in] address Device USB address.
    299167 * @param[in] index Configuration descriptor index.
    300168 * @param[out] descriptor Storage for the configuration descriptor.
    … …  
    338206 *
    339207 * @warning The @p buffer might be touched (i.e. its contents changed)
    340  * even when error occurs.
     208 * even when error occurres.
    341209 *
    342210 * @param[in] phone Open phone to HC driver.
    343  * @param[in] address Device address.
     211 * @param[in] address Device USB address.
    344212 * @param[in] index Configuration descriptor index.
    345213 * @param[out] buffer Buffer for the whole configuration descriptor.
    … …  
    353221    void *buffer, size_t buffer_size, size_t *actual_buffer_size)
    354222{
     223        if (buffer == NULL) {
     224                return EBADMEM;
     225        }
     226
    355227        int rc = usb_drv_req_get_descriptor(phone, address,
    356228            USB_REQUEST_TYPE_STANDARD,
    … …  
    363235}
    364236
    365 /** Update existing descriptor of a USB device.
    366  *
    367  * @param[in] hc_phone Open phone to HC driver.
    368  * @param[in] address Device address.
    369  * @param[in] descriptor_type Descriptor type (device/configuration/...).
    370  * @param[in] descriptor_index Descriptor index.
    371  * @param[in] language Language index.
    372  * @param[in] descriptor Actual descriptor data.
    373  * @param[in] descriptor_size Descriptor size.
    374  * @return Error code.
    375  */
    376 int usb_drv_req_set_descriptor(int hc_phone, usb_address_t address,
    377     uint8_t descriptor_type, uint8_t descriptor_index,
    378     uint16_t language,
    379     void *descriptor, size_t descriptor_size)
    380 {
    381         // FIXME: check that descriptor is not too big
    382 
    383         PREPARE_TARGET(target, address);
    384 
    385         PREPARE_SETUP_PACKET_LOHI(setup_packet, USB_DIRECTION_OUT,
    386             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    387             USB_DEVREQ_SET_DESCRIPTOR, descriptor_index, descriptor_type,
    388             language, descriptor_size);
    389 
    390         int rc = usb_drv_psync_control_write(hc_phone, target,
    391             &setup_packet, sizeof(setup_packet),
    392             descriptor, descriptor_size);
    393 
    394         return rc;
    395 }
    396 
    397 /** Determine current configuration value of USB device.
    398  *
    399  * @param[in] hc_phone Open phone to HC driver.
    400  * @param[in] address Device address.
    401  * @param[out] configuration_value Current configuration value.
    402  * @return Error code.
    403  */
    404 int usb_drv_req_get_configuration(int hc_phone, usb_address_t address,
    405     uint8_t *configuration_value)
    406 {
    407         if (configuration_value == NULL) {
    408                 return EBADMEM;
    409         }
    410 
    411         PREPARE_TARGET(target, address);
    412 
    413         PREPARE_SETUP_PACKET(setup_packet, USB_DIRECTION_IN,
    414             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    415             USB_DEVREQ_GET_CONFIGURATION, 0, 0, 1);
    416 
    417         uint8_t value;
    418         size_t transfered;
    419         int rc = usb_drv_psync_control_read(hc_phone, target,
    420             &setup_packet, sizeof(setup_packet), &value, 1, &transfered);
    421 
    422         if (rc != EOK) {
    423                 return rc;
    424         }
    425 
    426         if (transfered != 1) {
    427                 return ERANGE;
    428         }
    429 
    430         *configuration_value = value;
    431 
    432         return EOK;
    433 }
    434 
    435 /** Set configuration of USB device.
    436  *
    437  * @param[in] hc_phone Open phone to HC driver.
    438  * @param[in] address Device address.
    439  * @param[in] configuration_value New configuration value.
    440  * @return Error code.
    441  */
    442 int usb_drv_req_set_configuration(int hc_phone, usb_address_t address,
    443     uint8_t configuration_value)
    444 {
    445         PREPARE_TARGET(target, address);
    446 
    447         PREPARE_SETUP_PACKET_LOHI(setup_packet, USB_DIRECTION_OUT,
    448             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
    449             USB_DEVREQ_SET_CONFIGURATION, configuration_value, 0,
    450             0, 0);
    451 
    452         int rc = usb_drv_psync_control_write(hc_phone, target,
    453             &setup_packet, sizeof(setup_packet), NULL, 0);
    454 
    455         return rc;
    456 }
    457 
    458 /** Determine alternate setting of USB device interface.
    459  *
    460  * @param[in] hc_phone Open phone to HC driver.
    461  * @param[in] address Device address.
    462  * @param[in] interface_index Interface index.
    463  * @param[out] alternate_setting Value of alternate setting.
    464  * @return Error code.
    465  */
    466 int usb_drv_req_get_interface(int hc_phone, usb_address_t address,
    467     uint16_t interface_index, uint8_t *alternate_setting)
    468 {
    469         if (alternate_setting == NULL) {
    470                 return EBADMEM;
    471         }
    472 
    473         PREPARE_TARGET(target, address);
    474 
    475         PREPARE_SETUP_PACKET(setup_packet, USB_DIRECTION_IN,
    476             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE,
    477             USB_DEVREQ_GET_INTERFACE, 0, interface_index, 1);
    478 
    479         uint8_t alternate;
    480         size_t transfered;
    481         int rc = usb_drv_psync_control_read(hc_phone, target,
    482             &setup_packet, sizeof(setup_packet), &alternate, 1, &transfered);
    483 
    484         if (rc != EOK) {
    485                 return rc;
    486         }
    487 
    488         if (transfered != 1) {
    489                 return ERANGE;
    490         }
    491 
    492         *alternate_setting = alternate;
    493 
    494         return EOK;
    495 }
    496 
    497 /** Select an alternate setting of USB device interface.
    498  *
    499  * @param[in] hc_phone Open phone to HC driver.
    500  * @param[in] address Device address.
    501  * @param[in] interface_index Interface index.
    502  * @param[in] alternate_setting Value of alternate setting.
    503  * @return Error code.
    504  */
    505 int usb_drv_req_set_interface(int hc_phone, usb_address_t address,
    506     uint16_t interface_index, uint8_t alternate_setting)
    507 {
    508         PREPARE_TARGET(target, address);
    509 
    510         PREPARE_SETUP_PACKET_LOHI(setup_packet, USB_DIRECTION_OUT,
    511             USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE,
    512             USB_DEVREQ_SET_INTERFACE, alternate_setting, 0,
    513             0, 0);
    514 
    515         int rc = usb_drv_psync_control_write(hc_phone, target,
    516             &setup_packet, sizeof(setup_packet), NULL, 0);
    517 
    518         return rc;
    519 }
    520237
    521238/**
Note: See TracChangeset for help on using the changeset viewer.