Changeset b4b534ac in mainline for uspace/lib/usbvirt


Ignore:
Timestamp:
2016-07-22T08:24:47Z (9 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f76d2c2
Parents:
5b18137 (diff), 8351f9a4 (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 from lp:~jan.vesely/helenos/usb

Location:
uspace/lib/usbvirt
Files:
2 added
6 edited
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbvirt/Makefile

    r5b18137 rb4b534ac  
    3434        -I$(LIBUSB_PREFIX)/include \
    3535        -I$(LIBUSBDEV_PREFIX)/include \
    36         -Iinclude
     36        -Iinclude \
     37        -Iinclude/usbvirt
    3738
    3839SOURCES = \
    … …  
    4243        src/ipc_hc.c \
    4344        src/stdreq.c \
    44         src/transfer.c
     45        src/transfer.c \
     46        src/virthub_base.c \
     47        src/virthub_descriptors.c
    4548
    4649include $(USPACE_PREFIX)/Makefile.common

  • uspace/lib/usbvirt/include/usbvirt/device.h

    r5b18137 rb4b534ac  
    4040#include <usb/dev/request.h>
    4141#include <async.h>
     42#include <errno.h>
     43
    4244
    4345/** Maximum number of endpoints supported by virtual USB. */
    … …  
    5759typedef int (*usbvirt_on_data_to_device_t)(usbvirt_device_t *dev,
    5860    usb_endpoint_t endpoint, usb_transfer_type_t transfer_type,
    59     void *buffer, size_t buffer_size);
     61    const void *buffer, size_t buffer_size);
    6062
    6163/** Callback for data from device (IN transaction).
    … …  
    8890    uint8_t *data, size_t *act_data_size);
    8991
     92/** Create a class request to get data from device
     93 *
     94 * @param rec Request recipient.
     95 * @param req Request code.
     96 */
     97#define CLASS_REQ_IN(rec, req) \
     98        .request_type = SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_CLASS, rec), \
     99        .request = req
     100
     101/** Create a class request to send data to device
     102 *
     103 * @param rec Request recipient.
     104 * @param req Request code.
     105 */
     106#define CLASS_REQ_OUT(rec, req) \
     107        .request_type = SETUP_REQUEST_TO_DEVICE(USB_REQUEST_TYPE_CLASS, rec), \
     108        .request = req
     109
     110/** Create a standard request to get data from device
     111 *
     112 * @param rec Request recipient.
     113 * @param req Request code.
     114 */
     115#define STD_REQ_IN(rec, req) \
     116        .request_type = SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, rec), \
     117        .request = req
     118
     119/** Create a standard request to send data to device
     120 *
     121 * @param rec Request recipient.
     122 * @param req Request code.
     123 */
     124#define STD_REQ_OUT(rec, req) \
     125        .request_type = SETUP_REQUEST_TO_DEVICE(USB_REQUEST_TYPE_STANDARD, rec), \
     126        .request = req
     127
    90128/** Callback for control request on a virtual USB device.
    91129 *
    … …  
    94132 */
    95133typedef struct {
    96         /** Request direction (in or out). */
    97         usb_direction_t req_direction;
    98         /** Request recipient (device, interface or endpoint). */
    99         usb_request_recipient_t req_recipient;
    100         /** Request type (standard, class or vendor). */
    101         usb_request_type_t req_type;
     134        /* Request type. See usb/request.h */
     135        uint8_t request_type;
    102136        /** Actual request code. */
    103137        uint8_t request;
    … …  
    111145typedef struct {
    112146        /** Actual data. */
    113         uint8_t *data;
     147        const uint8_t *data;
    114148        /** Data length. */
    115149        size_t length;
    … …  
    121155        usb_standard_configuration_descriptor_t *descriptor;
    122156        /** Array of extra data. */
    123         usbvirt_device_configuration_extras_t *extra;
     157        const usbvirt_device_configuration_extras_t *extra;
    124158        /** Length of @c extra array. */
    125159        size_t extra_count;
    … …  
    131165         * There is always only one such descriptor for the device.
    132166         */
    133         usb_standard_device_descriptor_t *device;
     167        const usb_standard_device_descriptor_t *device;
    134168
    135169        /** Configurations. */
    … …  
    164198         * Last handler is expected to have the @c callback field set to NULL
    165199         */
    166         usbvirt_control_request_handler_t *control;
     200        const usbvirt_control_request_handler_t *control;
    167201        /** Callback when device changes state.
    168202         *
    … …  
    180214/** Virtual USB device. */
    181215struct usbvirt_device {
     216        /** Device does not require USB bus power */
     217        bool self_powered;
     218        /** Device is allowed to signal remote wakeup */
     219        bool remote_wakeup;
    182220        /** Name for debugging purposes. */
    183221        const char *name;
    … …  
    187225        usbvirt_device_ops_t *ops;
    188226        /** Device descriptors. */
    189         usbvirt_descriptors_t *descriptors;
     227        const usbvirt_descriptors_t *descriptors;
    190228        /** Current device address.
    191229         * You shall treat this field as read only in your code.
    … …  
    202240};
    203241
     242
     243int req_nop(usbvirt_device_t *device,
     244    const usb_device_request_setup_packet_t *setup_packet,
     245    uint8_t *data, size_t *act_size);
     246
    204247int usbvirt_device_plug(usbvirt_device_t *, const char *);
    205248void usbvirt_device_unplug(usbvirt_device_t *);
    206249
    207250void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *,
    208     uint8_t *, size_t *, void *, size_t);
    209 
    210 int usbvirt_control_write(usbvirt_device_t *, void *, size_t, void *, size_t);
    211 int usbvirt_control_read(usbvirt_device_t *, void *, size_t, void *, size_t, size_t *);
     251    uint8_t *, size_t *, const void *, size_t);
     252
     253int usbvirt_control_write(usbvirt_device_t *, const void *, size_t, void *, size_t);
     254int usbvirt_control_read(usbvirt_device_t *, const void *, size_t, void *, size_t, size_t *);
    212255int usbvirt_data_out(usbvirt_device_t *, usb_transfer_type_t, usb_endpoint_t,
    213     void *, size_t);
     256    const void *, size_t);
    214257int usbvirt_data_in(usbvirt_device_t *, usb_transfer_type_t, usb_endpoint_t,
    215258    void *, size_t, size_t *);

  • uspace/lib/usbvirt/include/usbvirt/virthub_base.h

    r5b18137 rb4b534ac  
    11/*
    2  * Copyright (c) 2010 Vojtech Horky
     2 * Copyright (c) 2013 Jan Vesely
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup drvusbvhc
     29/** @addtogroup libusbvirt
    3030 * @{
    3131 */
    3232/** @file
    33  * @brief Virtual USB hub.
     33 * Virtual USB device.
    3434 */
    3535
    36 #ifndef VHCD_HUB_H_
    37 #define VHCD_HUB_H_
     36#ifndef LIBUSBVIRT_VIRTHUB_BASE_H_
     37#define LIBUSBVIRT_VIRTHUB_BASE_H_
    3838
    3939#include <usbvirt/device.h>
    40 #include <ddf/driver.h>
     40#include <usb/classes/hub.h>
    4141
    42 #include "hub/hub.h"
    43 #include "hub/virthub.h"
     42enum {
     43        VIRTHUB_EXTR_DESC = 3,
     44};
    4445
    45 extern usbvirt_device_t virtual_hub_device;
     46typedef struct {
     47        usb_standard_configuration_descriptor_t config_descriptor;
     48        usb_standard_endpoint_descriptor_t endpoint_descriptor;
     49        usbvirt_device_configuration_extras_t extra[VIRTHUB_EXTR_DESC];
     50        usbvirt_device_configuration_t configuration;
     51        usbvirt_descriptors_t descriptors;
     52        usbvirt_device_t device;
     53        void *data;
     54} virthub_base_t;
    4655
    47 void virtual_hub_device_init(ddf_fun_t *);
     56void *virthub_get_data(usbvirt_device_t *dev);
     57
     58int virthub_base_init(virthub_base_t *instance,
     59    const char *name, usbvirt_device_ops_t *ops, void *data,
     60    const usb_standard_device_descriptor_t *device_desc,
     61    const usb_hub_descriptor_header_t *hub_desc, usb_endpoint_t ep);
     62
     63usb_address_t virthub_base_get_address(virthub_base_t *instance);
     64
     65int virthub_base_request(virthub_base_t *instance, usb_target_t target,
     66    usb_direction_t dir, const usb_device_request_setup_packet_t *setup,
     67    void *buffer, size_t buffer_size, size_t *real_size);
     68
     69int virthub_base_get_hub_descriptor(usbvirt_device_t *dev,
     70    const usb_device_request_setup_packet_t *request, uint8_t *data,
     71    size_t *act_size);
     72int virthub_base_get_null_status(usbvirt_device_t *dev,
     73    const usb_device_request_setup_packet_t *request, uint8_t *data,
     74    size_t *act_size);
     75
    4876
    4977#endif
     78
    5079/**
    5180 * @}

  • uspace/lib/usbvirt/src/ctrltransfer.c

    r5b18137 rb4b534ac  
    5050 */
    5151int process_control_transfer(usbvirt_device_t *dev,
    52     usbvirt_control_request_handler_t *control_handlers,
    53     usb_device_request_setup_packet_t *setup,
     52    const usbvirt_control_request_handler_t *control_handlers,
     53    const usb_device_request_setup_packet_t *setup,
    5454    uint8_t *data, size_t *data_sent_size)
    5555{
    … …  
    6060                return EFORWARD;
    6161        }
    62 
    63         usb_direction_t direction = setup->request_type & 128 ?
    64             USB_DIRECTION_IN : USB_DIRECTION_OUT;
    65         usb_request_recipient_t req_recipient = setup->request_type & 31;
    66         usb_request_type_t req_type = (setup->request_type >> 5) & 3;
    67 
    68         usbvirt_control_request_handler_t *handler = control_handlers;
    69         while (handler->callback != NULL) {
    70                 if (handler->req_direction != direction) {
    71                         goto next;
    72                 }
    73                 if (handler->req_recipient != req_recipient) {
    74                         goto next;
    75                 }
    76                 if (handler->req_type != req_type) {
    77                         goto next;
    78                 }
    79                 if (handler->request != setup->request) {
    80                         goto next;
     62        const usbvirt_control_request_handler_t *handler = control_handlers;
     63        for (;handler->callback != NULL; ++handler) {
     64                if (handler->request != setup->request ||
     65                    handler->request_type != setup->request_type) {
     66                        continue;
    8167                }
    8268
    … …  
    8470                    usb_debug_str_buffer((uint8_t*) setup, sizeof(*setup), 0));
    8571                int rc = handler->callback(dev, setup, data, data_sent_size);
    86                 if (rc == EFORWARD) {
    87                         goto next;
     72                if (rc != EFORWARD) {
     73                        return rc;
    8874                }
    8975
    90                 return rc;
    91 
    92 next:
    93                 handler++;
    9476        }
    9577

  • uspace/lib/usbvirt/src/private.h

    r5b18137 rb4b534ac  
    3939
    4040int process_control_transfer(usbvirt_device_t *,
    41     usbvirt_control_request_handler_t *,
    42     usb_device_request_setup_packet_t *,
     41    const usbvirt_control_request_handler_t *,
     42    const usb_device_request_setup_packet_t *,
    4343    uint8_t *, size_t *);
    4444

  • uspace/lib/usbvirt/src/stdreq.c

    r5b18137 rb4b534ac  
    5151void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *setup_packet,
    5252    uint8_t *data, size_t *act_size,
    53     void *actual_data, size_t actual_data_size)
     53    const void *actual_data, size_t actual_data_size)
    5454{
    5555        size_t expected_size = setup_packet->length;
    … …  
    6363                *act_size = actual_data_size;
    6464        }
     65}
     66
     67/** NOP handler */
     68int req_nop(usbvirt_device_t *device,
     69    const usb_device_request_setup_packet_t *setup_packet,
     70    uint8_t *data, size_t *act_size)
     71{
     72        return EOK;
    6573}
    6674
    … …  
    98106                }
    99107                /* Copy the data. */
    100                 usbvirt_device_configuration_t *config = &device->descriptors
    101                     ->configuration[index];
     108                const usbvirt_device_configuration_t *config =
     109                    &device->descriptors->configuration[index];
    102110                uint8_t *all_data = malloc(config->descriptor->total_length);
    103111                if (all_data == NULL) {
    … …  
    110118                size_t i;
    111119                for (i = 0; i < config->extra_count; i++) {
    112                         usbvirt_device_configuration_extras_t *extra
     120                        const usbvirt_device_configuration_extras_t *extra
    113121                            = &config->extra[i];
    114122                        memcpy(ptr, extra->data, extra->length);
    … …  
    189197}
    190198
     199static int req_get_dev_status(usbvirt_device_t *device,
     200    const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size)
     201{
     202        if (setup_packet->length != 2)
     203                return ESTALL;
     204        data[0] = (device->self_powered ? 1 : 0) | (device->remote_wakeup ? 2 : 0);
     205        data[1] = 0;
     206        *act_size = 2;
     207        return EOK;
     208}
     209static int req_get_iface_ep_status(usbvirt_device_t *device,
     210    const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size)
     211{
     212        if (setup_packet->length != 2)
     213                return ESTALL;
     214        data[0] = 0;
     215        data[1] = 0;
     216        *act_size = 2;
     217        return EOK;
     218}
     219
    191220/** Standard request handlers. */
    192221usbvirt_control_request_handler_t library_handlers[] = {
    193222        {
    194                 .req_direction = USB_DIRECTION_OUT,
    195                 .req_recipient = USB_REQUEST_RECIPIENT_DEVICE,
    196                 .req_type = USB_REQUEST_TYPE_STANDARD,
    197                 .request = USB_DEVREQ_SET_ADDRESS,
     223                STD_REQ_OUT(USB_REQUEST_RECIPIENT_DEVICE, USB_DEVREQ_SET_ADDRESS),
    198224                .name = "SetAddress",
    199225                .callback = req_set_address
    200226        },
    201227        {
    202                 .req_direction = USB_DIRECTION_IN,
    203                 .req_recipient = USB_REQUEST_RECIPIENT_DEVICE,
    204                 .req_type = USB_REQUEST_TYPE_STANDARD,
    205                 .request = USB_DEVREQ_GET_DESCRIPTOR,
    206                 .name = "GetDescriptor",
     228                STD_REQ_IN(USB_REQUEST_RECIPIENT_DEVICE, USB_DEVREQ_GET_DESCRIPTOR),
     229                .name = "GetStdDescriptor",
    207230                .callback = req_get_descriptor
    208231        },
    209232        {
    210                 .req_direction = USB_DIRECTION_OUT,
    211                 .req_recipient = USB_REQUEST_RECIPIENT_DEVICE,
    212                 .req_type = USB_REQUEST_TYPE_STANDARD,
    213                 .request = USB_DEVREQ_SET_CONFIGURATION,
     233                STD_REQ_OUT(USB_REQUEST_RECIPIENT_DEVICE, USB_DEVREQ_SET_CONFIGURATION),
    214234                .name = "SetConfiguration",
    215235                .callback = req_set_configuration
    216236        },
    217 
     237        {
     238                STD_REQ_IN(USB_REQUEST_RECIPIENT_DEVICE, USB_DEVREQ_GET_STATUS),
     239                .name = "GetDeviceStatus",
     240                .callback = req_get_dev_status,
     241        },
     242        {
     243                STD_REQ_IN(USB_REQUEST_RECIPIENT_INTERFACE, USB_DEVREQ_GET_STATUS),
     244                .name = "GetInterfaceStatus",
     245                .callback = req_get_iface_ep_status,
     246        },
     247        {
     248                /* virtual EPs by default cannot be stalled */
     249                STD_REQ_IN(USB_REQUEST_RECIPIENT_ENDPOINT, USB_DEVREQ_GET_STATUS),
     250                .name = "GetEndpointStatus",
     251                .callback = req_get_iface_ep_status,
     252        },
    218253        { .callback = NULL }
    219254};

  • uspace/lib/usbvirt/src/transfer.c

    r5b18137 rb4b534ac  
    5151 */
    5252static int usbvirt_control_transfer(usbvirt_device_t *dev,
    53     void *setup, size_t setup_size,
     53    const void *setup, size_t setup_size,
    5454    void *data, size_t data_size, size_t *data_size_sent)
    5555{
    … …  
    6060                return ESTALL;
    6161        }
    62         usb_device_request_setup_packet_t *setup_packet = setup;
     62        const usb_device_request_setup_packet_t *setup_packet = setup;
    6363        if (data_size != setup_packet->length) {
    6464                return ESTALL;
    … …  
    100100 * @return Error code.
    101101 */
    102 int usbvirt_control_write(usbvirt_device_t *dev, void *setup, size_t setup_size,
    103     void *data, size_t data_size)
     102int usbvirt_control_write(usbvirt_device_t *dev, const void *setup,
     103    size_t setup_size, void *data, size_t data_size)
    104104{
    105105        return usbvirt_control_transfer(dev, setup, setup_size,
    … …  
    119119 * @return Error code.
    120120 */
    121 int usbvirt_control_read(usbvirt_device_t *dev, void *setup, size_t setup_size,
     121int usbvirt_control_read(usbvirt_device_t *dev, const void *setup, size_t setup_size,
    122122    void *data, size_t data_size, size_t *data_size_sent)
    123123{
    … …  
    136136 */
    137137int usbvirt_data_out(usbvirt_device_t *dev, usb_transfer_type_t transf_type,
    138     usb_endpoint_t endpoint, void *data, size_t data_size)
     138    usb_endpoint_t endpoint, const void *data, size_t data_size)
    139139{
    140140        if ((endpoint <= 0) || (endpoint >= USBVIRT_ENDPOINT_MAX)) {
Note: See TracChangeset for help on using the changeset viewer.