Changeset 56257ba in mainline for uspace/lib/usbhost/src


Ignore:
Timestamp:
2018-01-07T01:01:42Z (8 years ago)
Author:
Ondřej Hlavatý <aearsis@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
63431db2
Parents:
9efad54
git-author:
Ondřej Hlavatý <aearsis@…> (2018-01-07 01:01:41)
git-committer:
Ondřej Hlavatý <aearsis@…> (2018-01-07 01:01:42)
Message:

usbhost: manage endpoints by library + get/set_toggle → reset_toggle

That simplifies things A LOT. Now you can find endpoints for device in
an array inside device. This array is managed automatically in
register/unregister endpoint. HC drivers still needs to write to it when
setting up/tearing down the device.

Sorry for these two changes being in one commit, but splitting them
would be simply more work for no benefit.

Location:
uspace/lib/usbhost/src
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r9efad54 r56257ba  
    9999
    100100        const bus_ops_t *ops = BUS_OPS_LOOKUP(dev->bus->ops, device_remove);
    101 
    102101        if (!ops)
    103102                return ENOTSUP;
    … …  
    162161
    163162        fibril_mutex_lock(&bus->guard);
    164         err = register_ops->endpoint_register(ep);
    165         fibril_mutex_unlock(&bus->guard);
     163        if (!device->online && ep->endpoint != 0) {
     164                err = EAGAIN;
     165        } else if (device->endpoints[ep->endpoint] != NULL) {
     166                err = EEXIST;
     167        } else {
     168                err = register_ops->endpoint_register(ep);
     169                if (!err)
     170                        device->endpoints[ep->endpoint] = ep;
     171        }
     172        fibril_mutex_unlock(&bus->guard);
     173        if (err) {
     174                endpoint_del_ref(ep);
     175                return err;
     176        }
    166177
    167178        if (out_ep) {
    … …  
    171182        }
    172183
    173         return err;
     184        return EOK;
    174185}
    175186
    176187/** Searches for an endpoint. Returns a reference.
    177188 */
    178 endpoint_t *bus_find_endpoint(device_t *device, usb_target_t endpoint, usb_direction_t dir)
     189endpoint_t *bus_find_endpoint(device_t *device, usb_endpoint_t endpoint)
    179190{
    180191        assert(device);
    … …  
    182193        bus_t *bus = device->bus;
    183194
    184         const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, device_find_endpoint);
    185         if (!ops)
    186                 return NULL;
    187 
    188         fibril_mutex_lock(&bus->guard);
    189         endpoint_t *ep = ops->device_find_endpoint(device, endpoint, dir);
     195        fibril_mutex_lock(&bus->guard);
     196        endpoint_t *ep = device->endpoints[endpoint];
    190197        if (ep) {
    191198                /* Exporting reference */
    192199                endpoint_add_ref(ep);
    193200        }
    194 
    195201        fibril_mutex_unlock(&bus->guard);
    196202        return ep;
    … …  
    201207        assert(ep);
    202208        assert(ep->device);
    203         assert(ep->device->bus);
    204         assert(ep->device->bus->ops);
    205209
    206210        bus_t *bus = endpoint_get_bus(ep);
    … …  
    218222        fibril_mutex_lock(&bus->guard);
    219223        const int r = ops->endpoint_unregister(ep);
     224        if (!r)
     225                ep->device->endpoints[ep->endpoint] = NULL;
    220226        fibril_mutex_unlock(&bus->guard);
    221227
    … …  
    253259        fibril_mutex_lock(&bus->guard);
    254260        const int r = ops->release_default_address(bus);
    255         fibril_mutex_unlock(&bus->guard);
    256         return r;
    257 }
    258 
    259 int bus_reset_toggle(bus_t *bus, usb_target_t target, bool all)
    260 {
    261         assert(bus);
    262 
    263         const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, reset_toggle);
    264         if (!ops)
    265                 return ENOTSUP;
    266 
    267         fibril_mutex_lock(&bus->guard);
    268         const int r = ops->reset_toggle(bus, target, all);
    269261        fibril_mutex_unlock(&bus->guard);
    270262        return r;
    … …  
    288280
    289281        /* Temporary reference */
    290         endpoint_t *ep = bus_find_endpoint(device, target, direction);
     282        endpoint_t *ep = bus_find_endpoint(device, target.endpoint);
    291283        if (ep == NULL) {
    292284                usb_log_error("Endpoint(%d:%d) not registered for %s.\n",

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

    r9efad54 r56257ba  
    106106        assert(dev);
    107107
    108         const usb_target_t target = {{
    109                 .address = dev->address,
    110                 .endpoint = endpoint_desc->endpoint_no
    111         }};
    112 
    113         endpoint_t *ep = bus_find_endpoint(dev, target, endpoint_desc->direction);
     108        endpoint_t *ep = bus_find_endpoint(dev, endpoint_desc->endpoint_no);
    114109        if (!ep)
    115110                return ENOENT;

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

    r9efad54 r56257ba  
    108108}
    109109
     110static void endpoint_toggle_reset(endpoint_t *ep, toggle_reset_mode_t mode);
     111
    110112/** Mark the endpoint as active and block access for further fibrils.
    111113 * @param ep endpoint_t structure.
    … …  
    132134
    133135        if (ep->active_batch && ep->active_batch->error == EOK)
    134                 usb_transfer_batch_reset_toggle(ep->active_batch);
     136                endpoint_toggle_reset(ep, ep->active_batch->toggle_reset_mode);
    135137
    136138        ep->active_batch = NULL;
    … …  
    155157}
    156158
    157 /** Get the value of toggle bit. Either uses the toggle_get op, or just returns
    158  * the value of the toggle.
    159  * @param ep endpoint_t structure.
    160  */
    161 int endpoint_toggle_get(endpoint_t *ep)
    162 {
    163         assert(ep);
    164 
    165         const bus_ops_t *ops = BUS_OPS_LOOKUP(get_bus_ops(ep), endpoint_get_toggle);
    166         return ops
    167             ? ops->endpoint_get_toggle(ep)
    168             : ep->toggle;
    169 }
    170 
    171 /** Set the value of toggle bit. Either uses the toggle_set op, or just sets
    172  * the toggle inside.
    173  * @param ep endpoint_t structure.
    174  */
    175 void endpoint_toggle_set(endpoint_t *ep, bool toggle)
    176 {
    177         assert(ep);
    178 
    179         const bus_ops_t *ops = BUS_OPS_LOOKUP(get_bus_ops(ep), endpoint_set_toggle);
    180         if (ops) {
    181                 ops->endpoint_set_toggle(ep, toggle);
    182         }
    183         else {
    184                 ep->toggle = toggle;
     159static void endpoint_toggle_reset(endpoint_t *ep, toggle_reset_mode_t mode)
     160{
     161        assert(ep);
     162
     163        if (mode == RESET_NONE)
     164                return;
     165
     166        const bus_ops_t *ops = BUS_OPS_LOOKUP(get_bus_ops(ep), endpoint_toggle_reset);
     167        if (!ops)
     168                return;
     169
     170        device_t *dev = ep->device;
     171
     172        if (mode == RESET_ALL) {
     173                for (usb_endpoint_t i = 0; i < USB_ENDPOINT_MAX; ++i) {
     174                        if (dev->endpoints[i])
     175                                ops->endpoint_toggle_reset(dev->endpoints[i]);
     176                }
     177        } else {
     178                ops->endpoint_toggle_reset(ep);
    185179        }
    186180}

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

    r9efad54 r56257ba  
    5757}
    5858
    59 /** Get list that holds endpoints for given address.
    60  * @param bus usb2_bus structure, non-null.
    61  * @param addr USB address, must be >= 0.
    62  * @return Pointer to the appropriate list.
    63  */
    64 static list_t * get_list(usb2_bus_t *bus, usb_address_t addr)
    65 {
    66         assert(bus);
    67         assert(addr >= 0);
    68         return &bus->devices[addr % ARRAY_SIZE(bus->devices)].endpoint_list;
    69 }
    70 
    71 /** Get speed assigned to USB address.
    72  *
    73  * @param[in] bus Device manager structure to use.
    74  * @param[in] address Address the caller wants to find.
    75  * @param[out] speed Assigned speed.
    76  * @return Error code.
    77  */
    78 static int get_speed(usb2_bus_t *bus, usb_address_t address, usb_speed_t *speed)
    79 {
    80         if (!usb_address_is_valid(address))
    81                 return EINVAL;
    82 
    83         if (!bus->devices[address].occupied)
    84                 return ENOENT;
    85 
    86         if (speed)
    87                 *speed = bus->devices[address].speed;
    88 
    89         return EOK;
    90 }
    91 
    9259/** Get a free USB address
    9360 *
    … …  
    10471                if (new_address == bus->last_address)
    10572                        return ENOSPC;
    106         } while (bus->devices[new_address].occupied);
     73        } while (bus->address_occupied[new_address]);
    10774
    10875        assert(new_address != USB_ADDRESS_DEFAULT);
    … …  
    12592                return EINVAL;
    12693
    127         const int ret = bus->devices[address].occupied ? EOK : ENOENT;
    128         bus->devices[address].occupied = false;
    129 
    130         list_t *list = get_list(bus, address);
    131         for (link_t *link = list_first(list); link != NULL; ) {
    132                 endpoint_t *ep = list_get_instance(link, endpoint_t, link);
    133                 link = list_next(link, list);
    134 
    135                 assert(ep->device->address == address);
    136                 list_remove(&ep->link);
    137 
    138                 usb_log_warning("Endpoint %d:%d %s was left behind, removing.\n",
    139                     address, ep->endpoint, usb_str_direction(ep->direction));
    140 
    141                 /* Drop bus reference */
    142                 endpoint_del_ref(ep);
    143         }
    144 
     94        const int ret = bus->address_occupied[address] ? EOK : ENOENT;
     95        bus->address_occupied[address] = false;
    14596        return ret;
    14697}
    … …  
    153104 * @note Default address is only available in strict mode.
    154105 */
    155 static int request_address(usb2_bus_t *bus, usb_address_t *addr, bool strict, usb_speed_t speed)
     106static int request_address(usb2_bus_t *bus, usb_address_t *addr, bool strict)
    156107{
    157108        int err;
    … …  
    168119                        return err;
    169120        }
    170         else if (bus->devices[*addr].occupied) {
     121        else if (bus->address_occupied[*addr]) {
    171122                if (strict) {
    172123                        return ENOENT;
    … …  
    177128
    178129        assert(usb_address_is_valid(*addr));
    179         assert(bus->devices[*addr].occupied == false);
     130        assert(bus->address_occupied[*addr] == false);
    180131        assert(*addr != USB_ADDRESS_DEFAULT || strict);
    181132
    182         bus->devices[*addr].occupied = true;
    183         bus->devices[*addr].speed = speed;
     133        bus->address_occupied[*addr] = true;
    184134
    185135        return EOK;
    … …  
    202152        /** Reserve address early, we want pretty log messages */
    203153        usb_address_t address = USB_ADDRESS_DEFAULT;
    204         if ((err = request_address(bus, &address, false, dev->speed))) {
     154        if ((err = request_address(bus, &address, false))) {
    205155                usb_log_error("Failed to reserve new address: %s.",
    206156                    str_error(err));
    … …  
    281231         * default address.
    282232         */
    283         if ((err = get_speed(bus, USB_ADDRESS_DEFAULT, &dev->speed))) {
    284                 usb_log_error("Failed to verify speed: %s.", str_error(err));
    285                 return err;
    286         }
     233        dev->speed = bus->default_address_speed;
    287234        usb_log_debug("Found new %s speed USB device.", usb_str_speed(dev->speed));
    288235
    … …  
    313260}
    314261
    315 /** Find endpoint.
    316  * @param bus usb_bus structure, non-null.
    317  * @param target Endpoint address.
    318  * @param direction Communication direction.
    319  * @return Pointer to endpoint_t structure representing given communication
    320  * target, NULL if there is no such endpoint registered.
    321  * @note Assumes that the internal mutex is locked.
    322  */
    323 static endpoint_t *usb2_bus_find_ep(device_t *device, usb_target_t target, usb_direction_t direction)
    324 {
    325         usb2_bus_t *bus = bus_to_usb2_bus(device->bus);
    326 
    327         assert(device->address == target.address);
    328 
    329         list_foreach(*get_list(bus, target.address), link, endpoint_t, ep) {
    330                 if (((direction == ep->direction)
    331                        || (ep->direction == USB_DIRECTION_BOTH)
    332                        || (direction == USB_DIRECTION_BOTH))
    333                     && (target.endpoint == ep->endpoint))
    334                         return ep;
    335         }
    336         return NULL;
    337 }
    338 
    339262static endpoint_t *usb2_bus_create_ep(device_t *dev, const usb_endpoint_descriptors_t *desc)
    340263{
    … …  
    347270}
    348271
    349 static usb_target_t usb2_ep_to_target(endpoint_t *ep)
    350 {
    351         assert(ep);
    352         assert(ep->device);
    353 
    354         return (usb_target_t) {{
    355                 .address = ep->device->address,
    356                 .endpoint = ep->endpoint,
    357         }};
    358 }
    359 
    360272/** Register an endpoint to the bus. Reserves bandwidth.
    361273 * @param bus usb_bus structure, non-null.
    … …  
    368280        assert(ep);
    369281
    370         /* Check for existence */
    371         if (usb2_bus_find_ep(ep->device, usb2_ep_to_target(ep), ep->direction))
    372                 return EEXIST;
    373 
    374282        /* Check for available bandwidth */
    375283        if (ep->bandwidth > bus->free_bw)
    376284                return ENOSPC;
    377285
    378         endpoint_add_ref(ep);
    379         list_append(&ep->link, get_list(bus, ep->device->address));
    380286        bus->free_bw -= ep->bandwidth;
    381287
    … …  
    390296        assert(ep);
    391297
    392         list_remove(&ep->link);
    393 
    394298        bus->free_bw += ep->bandwidth;
    395         endpoint_del_ref(ep);
    396 
    397         return EOK;
    398 }
    399 
    400 static int usb2_bus_reset_toggle(bus_t *bus_base, usb_target_t target, toggle_reset_mode_t mode)
    401 {
    402         usb2_bus_t *bus = bus_to_usb2_bus(bus_base);
    403 
    404         if (!usb_target_is_valid(target))
    405                 return EINVAL;
    406 
    407         if (mode == RESET_NONE)
    408                 return EOK;
    409 
    410         int ret = ENOENT;
    411 
    412         list_foreach(*get_list(bus, target.address), link, endpoint_t, ep) {
    413                 assert(ep->device->address == target.address);
    414 
    415                 if (mode == RESET_ALL || ep->endpoint == target.endpoint) {
    416                         endpoint_toggle_set(ep, 0);
    417                         ret = EOK;
    418                 }
    419         }
    420         return ret;
     299
     300        return EOK;
    421301}
    422302
    … …  
    425305        usb2_bus_t *bus = bus_to_usb2_bus(bus_base);
    426306        usb_address_t addr = USB_ADDRESS_DEFAULT;
    427         return request_address(bus, &addr, true, speed);
     307        const int err = request_address(bus, &addr, true);
     308        if (err)
     309                return err;
     310        bus->default_address_speed = speed;
     311        return EOK;
    428312}
    429313
    … …  
    437321        .reserve_default_address = usb2_bus_register_default_address,
    438322        .release_default_address = usb2_bus_release_default_address,
    439         .reset_toggle = usb2_bus_reset_toggle,
    440323        .device_enumerate = usb2_bus_device_enumerate,
    441         .device_find_endpoint = usb2_bus_find_ep,
    442324        .endpoint_create = usb2_bus_create_ep,
    443325        .endpoint_register = usb2_bus_register_ep,
    … …  
    460342
    461343        bus->free_bw = available_bandwidth;
    462         bus->last_address = 0;
    463         for (unsigned i = 0; i < ARRAY_SIZE(bus->devices); ++i) {
    464                 list_initialize(&bus->devices[i].endpoint_list);
    465                 bus->devices[i].speed = USB_SPEED_MAX;
    466                 bus->devices[i].occupied = false;
    467         }
     344
    468345        return EOK;
    469346}

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

    r9efad54 r56257ba  
    7171}
    7272
    73 /** Resolve resetting toggle.
    74  *
    75  * @param[in] batch Batch structure to use.
    76  */
    77 int usb_transfer_batch_reset_toggle(usb_transfer_batch_t *batch)
    78 {
    79         assert(batch);
    80 
    81         if (batch->error != EOK || batch->toggle_reset_mode == RESET_NONE)
    82                 return EOK;
    83 
    84         usb_log_debug2("Batch %p " USB_TRANSFER_BATCH_FMT " resets %s",
    85             batch, USB_TRANSFER_BATCH_ARGS(*batch),
    86             batch->toggle_reset_mode == RESET_ALL ? "all EPs toggle" : "EP toggle");
    87 
    88         return bus_reset_toggle(endpoint_get_bus(batch->ep), batch->target, batch->toggle_reset_mode);
    89 }
    90 
    9173/** Destroy the batch.
    9274 *
Note: See TracChangeset for help on using the changeset viewer.