Changeset 9efad54 in mainline for uspace/lib/usbhost


Ignore:
Timestamp:
2018-01-06T21:15:48Z (8 years ago)
Author:
Ondřej Hlavatý <aearsis@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
56257ba
Parents:
c901632
Message:

usb: move endpoint descriptor parsing to HC

This better separates responsibilities. Now the device driver does not
care about the contents of an endpoint descriptor, and HC can parse the
values according to device's actual speed.

Currently, it is device driver's responsibility to fetch endpoint
descriptors, map them and register pipes - sending the endpoint
descriptor back to HC. HC then parses it, and fills the pipe
description, which then sends back to device driver. We shall probably
fetch the endpoint descriptor from inside the HC (also fixing the USB
spec violation of communication with EP0).

Location:
uspace/lib/usbhost
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbhost/include/usb/host/bus.h

    rc901632 r9efad54  
    109109        int (*device_offline)(device_t *);                      /**< Optional */
    110110        endpoint_t *(*device_find_endpoint)(device_t*, usb_target_t, usb_direction_t);
    111         endpoint_t *(*endpoint_create)(device_t *, const usb_endpoint_desc_t *);
     111        endpoint_t *(*endpoint_create)(device_t *, const usb_endpoint_descriptors_t *);
    112112
    113113        /* Operations on endpoint */
    … …  
    163163    const char *);
    164164
    165 int bus_endpoint_add(device_t *, const usb_endpoint_desc_t *, endpoint_t **);
     165int bus_endpoint_add(device_t *, const usb_endpoint_descriptors_t *, endpoint_t **);
    166166endpoint_t *bus_find_endpoint(device_t *, usb_target_t, usb_direction_t);
    167167int bus_endpoint_remove(endpoint_t *);

  • uspace/lib/usbhost/include/usb/host/endpoint.h

    rc901632 r9efad54  
    4646#include <usb/usb.h>
    4747#include <usb/host/bus.h>
     48#include <usbhc_iface.h>
    4849
    4950typedef struct bus bus_t;
    … …  
    5960        /** Reference count. */
    6061        atomic_t refcnt;
    61         /** Enpoint number */
    62         usb_endpoint_t endpoint;
    63         /** Communication direction. */
    64         usb_direction_t direction;
    65         /** USB transfer type. */
    66         usb_transfer_type_t transfer_type;
    67         /** Maximum size of data packets. */
    68         size_t max_packet_size;
    69         /** Additional opportunities per uframe */
    70         unsigned packets;
    7162        /** Reserved bandwidth. */
    7263        size_t bandwidth;
    … …  
    8071        fibril_condvar_t avail;
    8172
     73        /** Enpoint number */
     74        usb_endpoint_t endpoint;
     75        /** Communication direction. */
     76        usb_direction_t direction;
     77        /** USB transfer type. */
     78        usb_transfer_type_t transfer_type;
     79        /** Maximum size of one packet */
     80        size_t max_packet_size;
     81
     82        /** Maximum size of one transfer */
     83        size_t max_transfer_size;
     84        /** Number of packats that can be sent in one service interval (not necessarily uframe) */
     85        unsigned packets_per_uframe;
     86
    8287        /* This structure is meant to be extended by overriding. */
    8388} endpoint_t;
    8489
    85 extern void endpoint_init(endpoint_t *, device_t *, const usb_endpoint_desc_t *);
     90extern void endpoint_init(endpoint_t *, device_t *, const usb_endpoint_descriptors_t *);
    8691
    8792extern void endpoint_add_ref(endpoint_t *);

  • uspace/lib/usbhost/src/bus.c

    rc901632 r9efad54  
    128128}
    129129
    130 int bus_endpoint_add(device_t *device, const usb_endpoint_desc_t *desc, endpoint_t **out_ep)
     130int bus_endpoint_add(device_t *device, const usb_endpoint_descriptors_t *desc, endpoint_t **out_ep)
    131131{
    132132        int err;
    … …  
    134134
    135135        bus_t *bus = device->bus;
    136 
    137         if (desc->max_packet_size == 0 || desc->packets == 0) {
    138                 usb_log_warning("Invalid endpoint description (mps %zu, %u packets)", desc->max_packet_size, desc->packets);
    139                 return EINVAL;
    140         }
    141136
    142137        const bus_ops_t *create_ops = BUS_OPS_LOOKUP(bus->ops, endpoint_create);
    … …  
    149144                return ENOMEM;
    150145
    151         /* Temporary reference */
     146        /* Bus reference */
    152147        endpoint_add_ref(ep);
     148
     149        if (ep->max_transfer_size == 0) {
     150                usb_log_warning("Invalid endpoint description (mps %zu, "
     151                        "%u packets)", ep->max_packet_size, ep->packets_per_uframe);
     152                /* Bus reference */
     153                endpoint_del_ref(ep);
     154                return EINVAL;
     155        }
     156
     157        usb_log_debug("Register endpoint %d:%d %s-%s %zuB.\n",
     158            device->address, ep->endpoint,
     159            usb_str_transfer_type(ep->transfer_type),
     160            usb_str_direction(ep->direction),
     161            ep->max_transfer_size);
    153162
    154163        fibril_mutex_lock(&bus->guard);
    … …  
    162171        }
    163172
    164         /* Temporary reference */
    165         endpoint_del_ref(ep);
    166173        return err;
    167174}
    … …  
    193200{
    194201        assert(ep);
     202        assert(ep->device);
     203        assert(ep->device->bus);
     204        assert(ep->device->bus->ops);
    195205
    196206        bus_t *bus = endpoint_get_bus(ep);
    197207
    198         const bus_ops_t *ops = BUS_OPS_LOOKUP(ep->device->bus->ops, endpoint_unregister);
    199         if (!ops)
    200                 return ENOTSUP;
     208        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, endpoint_unregister);
     209        if (!ops)
     210                return ENOTSUP;
     211
     212        usb_log_debug("Unregister endpoint %d:%d %s-%s %zuB.\n",
     213            ep->device->address, ep->endpoint,
     214            usb_str_transfer_type(ep->transfer_type),
     215            usb_str_direction(ep->direction),
     216            ep->max_transfer_size);
    201217
    202218        fibril_mutex_lock(&bus->guard);

  • uspace/lib/usbhost/src/ddf_helpers.c

    rc901632 r9efad54  
    5050
    5151#include "bus.h"
     52#include "endpoint.h"
    5253
    5354#include "ddf_helpers.h"
    … …  
    6566 * @return Error code.
    6667 */
    67 static int register_endpoint(
    68         ddf_fun_t *fun, usb_endpoint_desc_t *endpoint_desc)
     68static int register_endpoint(ddf_fun_t *fun, usb_pipe_desc_t *pipe_desc,
     69     const usb_endpoint_descriptors_t *ep_desc)
    6970{
    7071        assert(fun);
    … …  
    7576        assert(dev);
    7677
    77         usb_log_debug("Register endpoint %d:%d %s-%s %zuB %ums.\n",
    78                 dev->address, endpoint_desc->endpoint_no,
    79                 usb_str_transfer_type(endpoint_desc->transfer_type),
    80                 usb_str_direction(endpoint_desc->direction),
    81                 endpoint_desc->max_packet_size, endpoint_desc->interval);
    82 
    83         return bus_endpoint_add(dev, endpoint_desc, NULL);
     78        endpoint_t *ep;
     79        const int err = bus_endpoint_add(dev, ep_desc, &ep);
     80        if (err)
     81                return err;
     82
     83        if (pipe_desc) {
     84                pipe_desc->endpoint_no = ep->endpoint;
     85                pipe_desc->direction = ep->direction;
     86                pipe_desc->transfer_type = ep->transfer_type;
     87                pipe_desc->max_transfer_size = ep->max_transfer_size;
     88        }
     89        endpoint_del_ref(ep);
     90
     91        return EOK;
    8492}
    8593
    … …  
    8997  * @return Error code.
    9098  */
    91 static int unregister_endpoint(
    92         ddf_fun_t *fun, usb_endpoint_desc_t *endpoint_desc)
     99static int unregister_endpoint(ddf_fun_t *fun, const usb_pipe_desc_t *endpoint_desc)
    93100{
    94101        assert(fun);
    … …  
    103110                .endpoint = endpoint_desc->endpoint_no
    104111        }};
    105 
    106         usb_log_debug("Unregister endpoint %d:%d %s.\n",
    107                 dev->address, endpoint_desc->endpoint_no,
    108                 usb_str_direction(endpoint_desc->direction));
    109112
    110113        endpoint_t *ep = bus_find_endpoint(dev, target, endpoint_desc->direction);

  • uspace/lib/usbhost/src/endpoint.c

    rc901632 r9efad54  
    4141#include <str_error.h>
    4242#include <usb/debug.h>
     43#include <usb/descriptor.h>
    4344#include <usb/host/hcd.h>
    4445
    … …  
    5051/** Initialize provided endpoint structure.
    5152 */
    52 void endpoint_init(endpoint_t *ep, device_t *dev, const usb_endpoint_desc_t *desc)
     53void endpoint_init(endpoint_t *ep, device_t *dev, const usb_endpoint_descriptors_t *desc)
    5354{
    5455        memset(ep, 0, sizeof(endpoint_t));
    … …  
    6263        fibril_condvar_initialize(&ep->avail);
    6364
    64         ep->endpoint = desc->endpoint_no;
    65         ep->direction = desc->direction;
    66         ep->transfer_type = desc->transfer_type;
    67         ep->max_packet_size = desc->max_packet_size;
    68         ep->packets = desc->packets;
    69 
    70         ep->bandwidth = endpoint_count_bw(ep, desc->max_packet_size);
     65        ep->endpoint = USB_ED_GET_EP(desc->endpoint);
     66        ep->direction = USB_ED_GET_DIR(desc->endpoint);
     67        ep->transfer_type = USB_ED_GET_TRANSFER_TYPE(desc->endpoint);
     68        ep->max_packet_size = USB_ED_GET_MPS(desc->endpoint);
     69        ep->packets_per_uframe = USB_ED_GET_ADD_OPPS(desc->endpoint) + 1;
     70
     71        /** Direction both is our construct never present in descriptors */
     72        if (ep->transfer_type == USB_TRANSFER_CONTROL)
     73                ep->direction = USB_DIRECTION_BOTH;
     74
     75        ep->max_transfer_size = ep->max_packet_size * ep->packets_per_uframe;
     76
     77        ep->bandwidth = endpoint_count_bw(ep, ep->max_transfer_size);
    7178}
    7279

  • uspace/lib/usbhost/src/usb2_bus.c

    rc901632 r9efad54  
    186186}
    187187
    188 static const usb_endpoint_desc_t usb2_default_control_ep = {
    189         .endpoint_no = 0,
    190         .transfer_type = USB_TRANSFER_CONTROL,
    191         .direction = USB_DIRECTION_BOTH,
    192         .max_packet_size = CTRL_PIPE_MIN_PACKET_SIZE,
    193         .packets = 1,
    194 };
    195 
    196 
    197188static const usb_target_t usb2_default_target = {{
    198189        .address = USB_ADDRESS_DEFAULT,
    … …  
    221212        usb_log_debug("Device(%d): Adding default target (0:0)", address);
    222213
     214        usb_endpoint_descriptors_t ep0_desc = {
     215            .endpoint.max_packet_size = CTRL_PIPE_MIN_PACKET_SIZE,
     216        };
    223217        endpoint_t *default_ep;
    224         err = bus_endpoint_add(dev, &usb2_default_control_ep, &default_ep);
     218        err = bus_endpoint_add(dev, &ep0_desc, &default_ep);
    225219        if (err != EOK) {
    226220                usb_log_error("Device(%d): Failed to add default target: %s.",
    … …  
    229223        }
    230224
    231         uint16_t max_packet_size;
    232         if ((err = hcd_get_ep0_max_packet_size(&max_packet_size, &bus->base, dev)))
     225        if ((err = hcd_get_ep0_max_packet_size(&ep0_desc.endpoint.max_packet_size, &bus->base, dev)))
    233226                goto err_address;
    234227
    … …  
    254247        dev->address = address;
    255248
    256         const usb_endpoint_desc_t control_ep = {
    257                 .endpoint_no = 0,
    258                 .transfer_type = USB_TRANSFER_CONTROL,
    259                 .direction = USB_DIRECTION_BOTH,
    260                 .max_packet_size = max_packet_size,
    261                 .packets = 1,
    262         };
    263 
    264249        /* Register EP on the new address */
    265250        usb_log_debug("Device(%d): Registering control EP.", address);
    266         err = bus_endpoint_add(dev, &control_ep, NULL);
     251        err = bus_endpoint_add(dev, &ep0_desc, NULL);
    267252        if (err != EOK) {
    268253                usb_log_error("Device(%d): Failed to register EP0: %s",
    … …  
    352337}
    353338
    354 static endpoint_t *usb2_bus_create_ep(device_t *dev, const usb_endpoint_desc_t *desc)
     339static endpoint_t *usb2_bus_create_ep(device_t *dev, const usb_endpoint_descriptors_t *desc)
    355340{
    356341        endpoint_t *ep = malloc(sizeof(endpoint_t));
Note: See TracChangeset for help on using the changeset viewer.