Index: uspace/lib/usbhost/src/bandwidth.c =================================================================== --- uspace/lib/usbhost/src/bandwidth.c (revision 41924f3000a0433bb9a3bac4c10f0768464cc2e7) +++ uspace/lib/usbhost/src/bandwidth.c (revision 41924f3000a0433bb9a3bac4c10f0768464cc2e7) @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2011 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** @addtogroup libusbhost + * @{ + */ +/** @file + * + * Bandwidth calculation functions. Shared among uhci, ohci and ehci drivers. + */ + +#include + +#include +#include + +/** Calculate bandwidth that needs to be reserved for communication with EP. + * Calculation follows USB 1.1 specification. + * @param speed Device's speed. + * @param type Type of the transfer. + * @param size Number of byte to transfer. + * @param max_packet_size Maximum bytes in one packet. + */ +size_t bandwidth_count_usb11(usb_speed_t speed, usb_transfer_type_t type, + size_t size, size_t max_packet_size) +{ + /* We care about bandwidth only for interrupt and isochronous. */ + if ((type != USB_TRANSFER_INTERRUPT) + && (type != USB_TRANSFER_ISOCHRONOUS)) { + return 0; + } + + const unsigned packet_count = + (size + max_packet_size - 1) / max_packet_size; + /* TODO: It may be that ISO and INT transfers use only one packet per + * transaction, but I did not find text in USB spec to confirm this */ + /* NOTE: All data packets will be considered to be max_packet_size */ + switch (speed) + { + case USB_SPEED_LOW: + assert(type == USB_TRANSFER_INTERRUPT); + /* Protocol overhead 13B + * (3 SYNC bytes, 3 PID bytes, 2 Endpoint + CRC bytes, 2 + * CRC bytes, and a 3-byte interpacket delay) + * see USB spec page 45-46. */ + /* Speed penalty 8: low speed is 8-times slower*/ + return packet_count * (13 + max_packet_size) * 8; + case USB_SPEED_FULL: + /* Interrupt transfer overhead see above + * or page 45 of USB spec */ + if (type == USB_TRANSFER_INTERRUPT) + return packet_count * (13 + max_packet_size); + + assert(type == USB_TRANSFER_ISOCHRONOUS); + /* Protocol overhead 9B + * (2 SYNC bytes, 2 PID bytes, 2 Endpoint + CRC bytes, 2 CRC + * bytes, and a 1-byte interpacket delay) + * see USB spec page 42 */ + return packet_count * (9 + max_packet_size); + default: + return 0; + } +} + +/** Calculate bandwidth that needs to be reserved for communication with EP. + * Calculation follows USB 2.0 specification. + * @param speed Device's speed. + * @param type Type of the transfer. + * @param size Number of byte to transfer. + * @param max_packet_size Maximum bytes in one packet. + */ +size_t bandwidth_count_usb20(usb_speed_t speed, usb_transfer_type_t type, + size_t size, size_t max_packet_size) +{ + /* We care about bandwidth only for interrupt and isochronous. */ + if ((type != USB_TRANSFER_INTERRUPT) + && (type != USB_TRANSFER_ISOCHRONOUS)) { + return 0; + } + //TODO Implement + return 0; +} Index: uspace/lib/usbhost/src/bus.c =================================================================== --- uspace/lib/usbhost/src/bus.c (revision 41924f3000a0433bb9a3bac4c10f0768464cc2e7) +++ uspace/lib/usbhost/src/bus.c (revision 41924f3000a0433bb9a3bac4c10f0768464cc2e7) @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2017 Ondrej Hlavaty + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libusbhost + * @{ + */ +/** @file + * + */ + +#include +#include + +#include +#include + +/** + * Initializes the bus structure. + */ +void bus_init(bus_t *bus, hcd_t *hcd) +{ + memset(bus, 0, sizeof(bus_t)); + + bus->hcd = hcd; + fibril_mutex_initialize(&bus->guard); +} + +endpoint_t *bus_create_endpoint(bus_t *bus) +{ + assert(bus); + + fibril_mutex_lock(&bus->guard); + endpoint_t *ep = bus->ops.create_endpoint(bus); + if (ep) { + /* Exporting reference */ + endpoint_add_ref(ep); + } + fibril_mutex_unlock(&bus->guard); + + return ep; +} + +int bus_register_endpoint(bus_t *bus, endpoint_t *ep) +{ + assert(bus); + assert(ep); + + /* Bus reference */ + endpoint_add_ref(ep); + + fibril_mutex_lock(&bus->guard); + const int r = bus->ops.register_endpoint(bus, ep); + fibril_mutex_unlock(&bus->guard); + + return r; +} + +int bus_release_endpoint(bus_t *bus, endpoint_t *ep) +{ + int err; + + assert(bus); + assert(ep); + + fibril_mutex_lock(&bus->guard); + if ((err = bus->ops.release_endpoint(bus, ep))) + return err; + fibril_mutex_unlock(&bus->guard); + + /* Bus reference */ + endpoint_del_ref(ep); + + return EOK; +} + +/** Searches for an endpoint. Returns a reference. + */ +endpoint_t *bus_find_endpoint(bus_t *bus, usb_target_t target, usb_direction_t dir) +{ + assert(bus); + + fibril_mutex_lock(&bus->guard); + endpoint_t *ep = bus->ops.find_endpoint(bus, target, dir); + if (ep) { + /* Exporting reference */ + endpoint_add_ref(ep); + } + + fibril_mutex_unlock(&bus->guard); + return ep; +} + +int bus_request_address(bus_t *bus, usb_address_t *hint, bool strict, usb_speed_t speed) +{ + assert(bus); + + if (!bus->ops.request_address) + return ENOTSUP; + + fibril_mutex_lock(&bus->guard); + const int r = bus->ops.request_address(bus, hint, strict, speed); + fibril_mutex_unlock(&bus->guard); + return r; +} + +int bus_release_address(bus_t *bus, usb_address_t address) +{ + assert(bus); + + if (!bus->ops.release_address) + return ENOTSUP; + + fibril_mutex_lock(&bus->guard); + const int r = bus->ops.release_address(bus, address); + fibril_mutex_unlock(&bus->guard); + return r; +} + +int bus_get_speed(bus_t *bus, usb_address_t address, usb_speed_t *speed) +{ + assert(bus); + assert(speed); + + if (!bus->ops.get_speed) + return ENOTSUP; + + fibril_mutex_lock(&bus->guard); + const int r = bus->ops.get_speed(bus, address, speed); + fibril_mutex_unlock(&bus->guard); + return r; +} + +int bus_reset_toggle(bus_t *bus, usb_target_t target, bool all) +{ + assert(bus); + + if (!bus->ops.reset_toggle) + return ENOTSUP; + + fibril_mutex_lock(&bus->guard); + const int r = bus->ops.reset_toggle(bus, target, all); + fibril_mutex_unlock(&bus->guard); + return r; +} + +size_t bus_count_bw(endpoint_t *ep, size_t size) +{ + assert(ep); + + fibril_mutex_lock(&ep->guard); + const size_t bw = ep->bus->ops.count_bw(ep, size); + fibril_mutex_unlock(&ep->guard); + return bw; +} + +/** + * @} + */ Index: uspace/lib/usbhost/src/ddf_helpers.c =================================================================== --- uspace/lib/usbhost/src/ddf_helpers.c (revision 42bc933def8a0fa3c265ead66cec74d1ccb6798f) +++ uspace/lib/usbhost/src/ddf_helpers.c (revision 41924f3000a0433bb9a3bac4c10f0768464cc2e7) @@ -469,5 +469,5 @@ /* This checks whether the default address is reserved and gets speed */ - int ret = usb_bus_get_speed(&hcd->bus, USB_ADDRESS_DEFAULT, &speed); + int ret = bus_get_speed(hcd->bus, USB_ADDRESS_DEFAULT, &speed); if (ret != EOK) { usb_log_error("Failed to verify speed: %s.", str_error(ret)); @@ -623,5 +623,5 @@ assert(hcd); - hcd_reserve_default_address(hcd, hcd->bus.max_speed); + hcd_reserve_default_address(hcd, USB_SPEED_MAX); const int ret = hcd_ddf_new_device(device, NULL, 0); hcd_release_default_address(hcd); @@ -639,6 +639,5 @@ * This function does all the ddf work for hc driver. */ -int hcd_ddf_setup_hc(ddf_dev_t *device, usb_speed_t max_speed, - size_t bw, bw_count_func_t bw_count) +int hcd_ddf_setup_hc(ddf_dev_t *device) { assert(device); @@ -650,5 +649,5 @@ } instance->root_hub = NULL; - hcd_init(&instance->hcd, max_speed, bw, bw_count); + hcd_init(&instance->hcd); int ret = ENOMEM; @@ -851,20 +850,6 @@ { assert(driver); - static const struct { size_t bw; bw_count_func_t bw_count; }bw[] = { - [USB_SPEED_FULL] = { .bw = BANDWIDTH_AVAILABLE_USB11, - .bw_count = bandwidth_count_usb11 }, - [USB_SPEED_HIGH] = { .bw = BANDWIDTH_AVAILABLE_USB11, - .bw_count = bandwidth_count_usb11 }, - [USB_SPEED_SUPER] = { .bw = BANDWIDTH_AVAILABLE_USB11, - .bw_count = bandwidth_count_usb11 }, - }; int ret = EOK; - const usb_speed_t speed = driver->hc_speed; - if (speed >= ARRAY_SIZE(bw) || bw[speed].bw == 0) { - usb_log_error("Driver `%s' reported unsupported speed: %s", - driver->name, usb_str_speed(speed)); - return ENOTSUP; - } hw_res_list_parsed_t hw_res; @@ -877,5 +862,5 @@ } - ret = hcd_ddf_setup_hc(device, speed, bw[speed].bw, bw[speed].bw_count); + ret = hcd_ddf_setup_hc(device); if (ret != EOK) { usb_log_error("Failed to setup generic HCD.\n"); Index: uspace/lib/usbhost/src/endpoint.c =================================================================== --- uspace/lib/usbhost/src/endpoint.c (revision 42bc933def8a0fa3c265ead66cec74d1ccb6798f) +++ uspace/lib/usbhost/src/endpoint.c (revision 41924f3000a0433bb9a3bac4c10f0768464cc2e7) @@ -1,4 +1,5 @@ /* * Copyright (c) 2011 Jan Vesely + * Copyright (c) 2017 Ondrej Hlavaty * All rights reserved. * @@ -35,157 +36,106 @@ #include +#include #include +#include +#include #include -#include -/** Allocate ad initialize endpoint_t structure. - * @param address USB address. - * @param endpoint USB endpoint number. - * @param direction Communication direction. - * @param type USB transfer type. - * @param speed Communication speed. - * @param max_packet_size Maximum size of data packets. - * @param bw Required bandwidth. - * @return Pointer to initialized endpoint_t structure, NULL on failure. +/** Initialize provided endpoint structure. */ -endpoint_t * endpoint_create(usb_address_t address, usb_endpoint_t endpoint, - usb_direction_t direction, usb_transfer_type_t type, usb_speed_t speed, - size_t max_packet_size, unsigned packets, size_t bw, - usb_address_t tt_address, unsigned tt_p) +void endpoint_init(endpoint_t *ep, bus_t *bus) { - endpoint_t *instance = malloc(sizeof(endpoint_t)); - if (instance) { - atomic_set(&instance->refcnt, 0); - instance->address = address; - instance->endpoint = endpoint; - instance->direction = direction; - instance->transfer_type = type; - instance->speed = speed; - instance->max_packet_size = max_packet_size; - instance->packets = packets; - instance->bandwidth = bw; - instance->toggle = 0; - instance->active = false; - instance->tt.address = tt_address; - instance->tt.port = tt_p; - instance->hc_data.data = NULL; - instance->hc_data.toggle_get = NULL; - instance->hc_data.toggle_set = NULL; - link_initialize(&instance->link); - fibril_mutex_initialize(&instance->guard); - fibril_condvar_initialize(&instance->avail); - } - return instance; + memset(ep, 0, sizeof(endpoint_t)); + + ep->bus = bus; + atomic_set(&ep->refcnt, 0); + link_initialize(&ep->link); + fibril_mutex_initialize(&ep->guard); + fibril_condvar_initialize(&ep->avail); } -/** Properly dispose of endpoint_t structure. - * @param instance endpoint_t structure. - */ -void endpoint_destroy(endpoint_t *instance) +void endpoint_add_ref(endpoint_t *ep) { - assert(instance); - assert(!instance->active); - assert(instance->hc_data.data == NULL); - free(instance); + atomic_inc(&ep->refcnt); } -void endpoint_add_ref(endpoint_t *instance) +void endpoint_del_ref(endpoint_t *ep) { - atomic_inc(&instance->refcnt); -} + if (atomic_predec(&ep->refcnt) == 0) { + if (ep->bus->ops.destroy_endpoint) { + ep->bus->ops.destroy_endpoint(ep); + } + else { + assert(!ep->active); -void endpoint_del_ref(endpoint_t *instance) -{ - if (atomic_predec(&instance->refcnt) == 0) - endpoint_destroy(instance); -} - -/** Set device specific data and hooks. - * @param instance endpoint_t structure. - * @param data device specific data. - * @param toggle_get Hook to call when retrieving value of toggle bit. - * @param toggle_set Hook to call when setting the value of toggle bit. - */ -void endpoint_set_hc_data(endpoint_t *instance, - void *data, int (*toggle_get)(void *), void (*toggle_set)(void *, int)) -{ - assert(instance); - fibril_mutex_lock(&instance->guard); - instance->hc_data.data = data; - instance->hc_data.toggle_get = toggle_get; - instance->hc_data.toggle_set = toggle_set; - fibril_mutex_unlock(&instance->guard); -} - -/** Clear device specific data and hooks. - * @param instance endpoint_t structure. - * @note This function does not free memory pointed to by data pointer. - */ -void endpoint_clear_hc_data(endpoint_t *instance) -{ - assert(instance); - endpoint_set_hc_data(instance, NULL, NULL, NULL); + /* Assume mostly the eps will be allocated by malloc. */ + free(ep); + } + } } /** Mark the endpoint as active and block access for further fibrils. - * @param instance endpoint_t structure. + * @param ep endpoint_t structure. */ -void endpoint_use(endpoint_t *instance) +void endpoint_use(endpoint_t *ep) { - assert(instance); + assert(ep); /* Add reference for active endpoint. */ - endpoint_add_ref(instance); - fibril_mutex_lock(&instance->guard); - while (instance->active) - fibril_condvar_wait(&instance->avail, &instance->guard); - instance->active = true; - fibril_mutex_unlock(&instance->guard); + endpoint_add_ref(ep); + fibril_mutex_lock(&ep->guard); + while (ep->active) + fibril_condvar_wait(&ep->avail, &ep->guard); + ep->active = true; + fibril_mutex_unlock(&ep->guard); } /** Mark the endpoint as inactive and allow access for further fibrils. - * @param instance endpoint_t structure. + * @param ep endpoint_t structure. */ -void endpoint_release(endpoint_t *instance) +void endpoint_release(endpoint_t *ep) { - assert(instance); - fibril_mutex_lock(&instance->guard); - instance->active = false; - fibril_mutex_unlock(&instance->guard); - fibril_condvar_signal(&instance->avail); + assert(ep); + fibril_mutex_lock(&ep->guard); + ep->active = false; + fibril_mutex_unlock(&ep->guard); + fibril_condvar_signal(&ep->avail); /* Drop reference for active endpoint. */ - endpoint_del_ref(instance); + endpoint_del_ref(ep); } -/** Get the value of toggle bit. - * @param instance endpoint_t structure. - * @note Will use provided hook. +/** Get the value of toggle bit. Either uses the toggle_get op, or just returns + * the value of the toggle. + * @param ep endpoint_t structure. */ -int endpoint_toggle_get(endpoint_t *instance) +int endpoint_toggle_get(endpoint_t *ep) { - assert(instance); - fibril_mutex_lock(&instance->guard); - if (instance->hc_data.toggle_get) - instance->toggle = - instance->hc_data.toggle_get(instance->hc_data.data); - const int ret = instance->toggle; - fibril_mutex_unlock(&instance->guard); + assert(ep); + fibril_mutex_lock(&ep->guard); + const int ret = ep->bus->ops.endpoint_get_toggle + ? ep->bus->ops.endpoint_get_toggle(ep) + : ep->toggle; + fibril_mutex_unlock(&ep->guard); return ret; } -/** Set the value of toggle bit. - * @param instance endpoint_t structure. - * @note Will use provided hook. +/** Set the value of toggle bit. Either uses the toggle_set op, or just sets + * the toggle inside. + * @param ep endpoint_t structure. */ -void endpoint_toggle_set(endpoint_t *instance, int toggle) +void endpoint_toggle_set(endpoint_t *ep, unsigned toggle) { - assert(instance); + assert(ep); assert(toggle == 0 || toggle == 1); - fibril_mutex_lock(&instance->guard); - instance->toggle = toggle; - if (instance->hc_data.toggle_set) - instance->hc_data.toggle_set(instance->hc_data.data, toggle); - fibril_mutex_unlock(&instance->guard); + fibril_mutex_lock(&ep->guard); + if (ep->bus->ops.endpoint_set_toggle) { + ep->bus->ops.endpoint_set_toggle(ep, toggle); + } + else { + ep->toggle = toggle; + } + fibril_mutex_unlock(&ep->guard); } + /** Index: uspace/lib/usbhost/src/hcd.c =================================================================== --- uspace/lib/usbhost/src/hcd.c (revision 42bc933def8a0fa3c265ead66cec74d1ccb6798f) +++ uspace/lib/usbhost/src/hcd.c (revision 41924f3000a0433bb9a3bac4c10f0768464cc2e7) @@ -44,9 +44,11 @@ #include "hcd.h" -/** Calls ep_add_hook upon endpoint registration. + +/*[>* Calls ep_add_hook upon endpoint registration. * @param ep Endpoint to be registered. * @param arg hcd_t in disguise. * @return Error code. - */ + * OH TODO: remove + <] static int register_helper(endpoint_t *ep, void *arg) { @@ -59,8 +61,9 @@ } -/** Calls ep_remove_hook upon endpoint removal. +[>* Calls ep_remove_hook upon endpoint removal. * @param ep Endpoint to be unregistered. * @param arg hcd_t in disguise. - */ + * OH TODO: remove + <] static void unregister_helper(endpoint_t *ep, void *arg) { @@ -72,16 +75,17 @@ } -/** Calls ep_remove_hook upon endpoint removal. Prints warning. +[>* Calls ep_remove_hook upon endpoint removal. Prints warning. * * @param ep Endpoint to be unregistered. * * @param arg hcd_t in disguise. - * */ + * OH TODO: remove + * <] static void unregister_helper_warn(endpoint_t *ep, void *arg) { assert(ep); usb_log_warning("Endpoint %d:%d %s was left behind, removing.\n", - ep->address, ep->endpoint, usb_str_direction(ep->direction)); + ep->target.address, ep->target.endpoint, usb_str_direction(ep->direction)); unregister_helper(ep, arg); } - +*/ /** Initialize hcd_t structure. @@ -93,11 +97,8 @@ * @param bw_count Bandwidth compute function, passed to endpoint manager. */ -void hcd_init(hcd_t *hcd, usb_speed_t max_speed, size_t bandwidth, - bw_count_func_t bw_count) -{ - assert(hcd); - usb_bus_init(&hcd->bus, bandwidth, bw_count, max_speed); - - hcd_set_implementation(hcd, NULL, NULL); +void hcd_init(hcd_t *hcd) { + assert(hcd); + + hcd_set_implementation(hcd, NULL, NULL, NULL); } @@ -106,6 +107,5 @@ assert(hcd); usb_address_t address = 0; - const int ret = usb_bus_request_address( - &hcd->bus, &address, false, speed); + const int ret = bus_request_address(hcd->bus, &address, false, speed); if (ret != EOK) return ret; @@ -116,6 +116,6 @@ { assert(hcd); - return usb_bus_remove_address(&hcd->bus, address, - unregister_helper_warn, hcd); + return bus_release_address(hcd->bus, address); + // OH TODO removed helper } @@ -124,5 +124,5 @@ assert(hcd); usb_address_t address = 0; - return usb_bus_request_address(&hcd->bus, &address, true, speed); + return bus_request_address(hcd->bus, &address, true, speed); } @@ -132,7 +132,25 @@ { assert(hcd); - return usb_bus_add_ep(&hcd->bus, target.address, - target.endpoint, dir, type, max_packet_size, packets, size, - register_helper, hcd, tt_address, tt_port); + + /* Temporary reference */ + endpoint_t *ep = bus_create_endpoint(hcd->bus); + if (!ep) + return ENOMEM; + + ep->target = target; + ep->direction = dir; + ep->transfer_type = type; + ep->max_packet_size = max_packet_size; + ep->packets = packets; + + ep->tt.address = tt_address; + ep->tt.port = tt_port; + + const int err = bus_register_endpoint(hcd->bus, ep); + + /* drop Temporary reference */ + endpoint_del_ref(ep); + + return err; } @@ -140,6 +158,10 @@ { assert(hcd); - return usb_bus_remove_ep(&hcd->bus, target.address, - target.endpoint, dir, unregister_helper, hcd); + endpoint_t *ep = bus_find_endpoint(hcd->bus, target, dir); + if (!ep) + return ENOENT; + + return bus_release_endpoint(hcd->bus, ep); + // OH TODO removed helper } @@ -159,5 +181,5 @@ usb_log_debug2("Reseting toggle on %d:%d.\n", toggle->target.address, toggle->target.endpoint); - usb_bus_reset_toggle(&toggle->hcd->bus, + bus_reset_toggle(toggle->hcd->bus, toggle->target, toggle->target.endpoint == 0); } @@ -185,6 +207,5 @@ assert(hcd); - endpoint_t *ep = usb_bus_find_ep(&hcd->bus, - target.address, target.endpoint, direction); + endpoint_t *ep = bus_find_endpoint(hcd->bus, target, direction); if (ep == NULL) { usb_log_error("Endpoint(%d:%d) not registered for %s.\n", @@ -196,11 +217,10 @@ name, target.address, target.endpoint, size, ep->max_packet_size); - const size_t bw = bandwidth_count_usb11( - ep->speed, ep->transfer_type, size, ep->max_packet_size); + const size_t bw = bus_count_bw(ep, size); /* Check if we have enough bandwidth reserved */ if (ep->bandwidth < bw) { usb_log_error("Endpoint(%d:%d) %s needs %zu bw " "but only %zu is reserved.\n", - ep->address, ep->endpoint, name, bw, ep->bandwidth); + ep->target.address, ep->target.endpoint, name, bw, ep->bandwidth); return ENOSPC; } Index: uspace/lib/usbhost/src/usb2_bus.c =================================================================== --- uspace/lib/usbhost/src/usb2_bus.c (revision 41924f3000a0433bb9a3bac4c10f0768464cc2e7) +++ uspace/lib/usbhost/src/usb2_bus.c (revision 41924f3000a0433bb9a3bac4c10f0768464cc2e7) @@ -0,0 +1,309 @@ +/* + * Copyright (c) 2011 Jan Vesely + * Copyright (c) 2017 Ondrej Hlavaty + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/** @addtogroup libusbhost + * @{ + */ +/** @file + * HC Endpoint management. + */ + +#include +#include +#include + +#include +#include +#include +#include + +/** Ops receive generic bus_t pointer. */ +static inline usb2_bus_t *bus_to_usb2_bus(bus_t *bus_base) +{ + assert(bus_base); + return (usb2_bus_t *) bus_base; +} + +/** Get list that holds endpoints for given address. + * @param bus usb2_bus structure, non-null. + * @param addr USB address, must be >= 0. + * @return Pointer to the appropriate list. + */ +static list_t * get_list(usb2_bus_t *bus, usb_address_t addr) +{ + assert(bus); + assert(addr >= 0); + return &bus->devices[addr % ARRAY_SIZE(bus->devices)].endpoint_list; +} + +/** Get a free USB address + * + * @param[in] bus Device manager structure to use. + * @return Free address, or error code. + */ +static int usb_bus_get_free_address(usb2_bus_t *bus, usb_address_t *addr) +{ + usb_address_t new_address = bus->last_address; + do { + new_address = (new_address + 1) % USB_ADDRESS_COUNT; + if (new_address == USB_ADDRESS_DEFAULT) + new_address = 1; + if (new_address == bus->last_address) + return ENOSPC; + } while (bus->devices[new_address].occupied); + + assert(new_address != USB_ADDRESS_DEFAULT); + bus->last_address = new_address; + + *addr = new_address; + return EOK; +} + +/** Find endpoint. + * @param bus usb_bus structure, non-null. + * @param target Endpoint address. + * @param direction Communication direction. + * @return Pointer to endpoint_t structure representing given communication + * target, NULL if there is no such endpoint registered. + * @note Assumes that the internal mutex is locked. + */ +static endpoint_t *usb2_bus_find_ep(bus_t *bus_base, usb_target_t target, usb_direction_t direction) +{ + usb2_bus_t *bus = bus_to_usb2_bus(bus_base); + + if (!usb_address_is_valid(target.address)) + return NULL; + + list_foreach(*get_list(bus, target.address), link, endpoint_t, ep) { + if (((direction == ep->direction) + || (ep->direction == USB_DIRECTION_BOTH) + || (direction == USB_DIRECTION_BOTH)) + && (target.packed == ep->target.packed)) + return ep; + } + return NULL; +} + +/** Register an endpoint to the bus. Reserves bandwidth. + * @param bus usb_bus structure, non-null. + * @param endpoint USB endpoint number. + */ +static int usb2_bus_register_ep(bus_t *bus_base, endpoint_t *ep) +{ + usb2_bus_t *bus = bus_to_usb2_bus(bus_base); + assert(ep); + + usb_address_t address = ep->target.address; + + if (!usb_address_is_valid(address)) + return EINVAL; + + /* Check for speed and address */ + if (!bus->devices[address].occupied) + return ENOENT; + + /* Check for existence */ + if (usb2_bus_find_ep(bus_base, ep->target, ep->direction)) + return EEXIST; + + /* Check for available bandwidth */ + if (ep->bandwidth > bus->free_bw) + return ENOSPC; + + list_append(&ep->link, get_list(bus, ep->target.address)); + bus->free_bw -= ep->bandwidth; + + return EOK; +} + + +/** Release bandwidth reserved by the given endpoint. + */ +static int usb2_bus_release_ep(bus_t *bus_base, endpoint_t *ep) +{ + usb2_bus_t *bus = bus_to_usb2_bus(bus_base); + assert(ep); + + bus->free_bw += ep->bandwidth; + + return EOK; +} + +static int usb2_bus_reset_toggle(bus_t *bus_base, usb_target_t target, bool all) +{ + usb2_bus_t *bus = bus_to_usb2_bus(bus_base); + + if (!usb_target_is_valid(target)) + return EINVAL; + + int ret = ENOENT; + + list_foreach(*get_list(bus, target.address), link, endpoint_t, ep) { + if ((ep->target.address == target.address) + && (all || ep->target.endpoint == target.endpoint)) { + endpoint_toggle_set(ep, 0); + ret = EOK; + } + } + return ret; +} + +/** Unregister and destroy all endpoints using given address. + * @param bus usb_bus structure, non-null. + * @param address USB address. + * @param endpoint USB endpoint number. + * @param direction Communication direction. + * @param callback Function to call after unregister, before destruction. + * @arg Argument to pass to the callback function. + * @return Error code. + */ +static int usb2_bus_release_address(bus_t *bus_base, usb_address_t address) +{ + usb2_bus_t *bus = bus_to_usb2_bus(bus_base); + + if (!usb_address_is_valid(address)) + return EINVAL; + + const int ret = bus->devices[address].occupied ? EOK : ENOENT; + bus->devices[address].occupied = false; + + list_t *list = get_list(bus, address); + for (link_t *link = list_first(list); link != NULL; ) { + endpoint_t *ep = list_get_instance(link, endpoint_t, link); + link = list_next(link, list); + assert(ep->target.address == address); + list_remove(&ep->link); + + /* Drop bus reference */ + endpoint_del_ref(ep); + } + + return ret; +} + +/** Request USB address. + * @param bus usb_device_manager + * @param addr Pointer to requested address value, place to store new address + * @parma strict Fail if the requested address is not available. + * @return Error code. + * @note Default address is only available in strict mode. + */ +static int usb2_bus_request_address(bus_t *bus_base, usb_address_t *addr, bool strict, usb_speed_t speed) +{ + int err; + + usb2_bus_t *bus = bus_to_usb2_bus(bus_base); + assert(addr); + + if (!usb_address_is_valid(*addr)) + return EINVAL; + + /* Only grant default address to strict requests */ + if ((*addr == USB_ADDRESS_DEFAULT) && !strict) { + if ((err = usb_bus_get_free_address(bus, addr))) + return err; + } + else if (bus->devices[*addr].occupied) { + if (strict) { + return ENOENT; + } + if ((err = usb_bus_get_free_address(bus, addr))) + return err; + } + + assert(usb_address_is_valid(*addr)); + assert(bus->devices[*addr].occupied == false); + assert(*addr != USB_ADDRESS_DEFAULT || strict); + + bus->devices[*addr].occupied = true; + bus->devices[*addr].speed = speed; + + return EOK; +} + +/** Get speed assigned to USB address. + * + * @param[in] bus Device manager structure to use. + * @param[in] address Address the caller wants to find. + * @param[out] speed Assigned speed. + * @return Error code. + */ +static int usb2_bus_get_speed(bus_t *bus_base, usb_address_t address, usb_speed_t *speed) +{ + usb2_bus_t *bus = bus_to_usb2_bus(bus_base); + + if (!usb_address_is_valid(address)) { + return EINVAL; + } + + const int ret = bus->devices[address].occupied ? EOK : ENOENT; + if (speed && bus->devices[address].occupied) { + *speed = bus->devices[address].speed; + } + + return ret; +} + +static const bus_ops_t usb2_bus_ops = { + .find_endpoint = usb2_bus_find_ep, + .release_endpoint = usb2_bus_release_ep, + .register_endpoint = usb2_bus_register_ep, + .request_address = usb2_bus_request_address, + .release_address = usb2_bus_release_address, + .reset_toggle = usb2_bus_reset_toggle, + .get_speed = usb2_bus_get_speed, +}; + +/** Initialize to default state. + * + * @param bus usb_bus structure, non-null. + * @param available_bandwidth Size of the bandwidth pool. + * @param bw_count function to use to calculate endpoint bw requirements. + * @return Error code. + */ +int usb2_bus_init(usb2_bus_t *bus, hcd_t *hcd, size_t available_bandwidth, count_bw_func_t count_bw) +{ + assert(bus); + + bus_init(&bus->bus, hcd); + + bus->bus.ops = usb2_bus_ops; + bus->bus.ops.count_bw = count_bw; + + bus->free_bw = available_bandwidth; + bus->last_address = 0; + for (unsigned i = 0; i < ARRAY_SIZE(bus->devices); ++i) { + list_initialize(&bus->devices[i].endpoint_list); + bus->devices[i].speed = USB_SPEED_MAX; + bus->devices[i].occupied = false; + } + return EOK; +} +/** + * @} + */ Index: uspace/lib/usbhost/src/usb_bus.c =================================================================== --- uspace/lib/usbhost/src/usb_bus.c (revision 42bc933def8a0fa3c265ead66cec74d1ccb6798f) +++ (revision ) @@ -1,548 +1,0 @@ -/* - * Copyright (c) 2011 Jan Vesely - * All rights eps. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/** @addtogroup libusbhost - * @{ - */ -/** @file - * HC Endpoint management. - */ - -#include -#include - -#include -#include -#include -#include - - -/** Endpoint compare helper function. - * - * USB_DIRECTION_BOTH matches both IN and OUT. - * @param ep Endpoint to compare, non-null. - * @param address Tested address. - * @param endpoint Tested endpoint number. - * @param direction Tested direction. - * @return True if ep can be used to communicate with given device, - * false otherwise. - */ -static inline bool ep_match(const endpoint_t *ep, - usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction) -{ - assert(ep); - return - ((direction == ep->direction) - || (ep->direction == USB_DIRECTION_BOTH) - || (direction == USB_DIRECTION_BOTH)) - && (endpoint == ep->endpoint) - && (address == ep->address); -} - -/** Get list that holds endpoints for given address. - * @param instance usb_bus structure, non-null. - * @param addr USB address, must be >= 0. - * @return Pointer to the appropriate list. - */ -static list_t * get_list(usb_bus_t *instance, usb_address_t addr) -{ - assert(instance); - assert(addr >= 0); - return &instance->devices[addr % ARRAY_SIZE(instance->devices)].endpoint_list; -} - -/** Internal search function, works on locked structure. - * @param instance usb_bus structure, non-null. - * @param address USB address, must be valid. - * @param endpoint USB endpoint number. - * @param direction Communication direction. - * @return Pointer to endpoint_t structure representing given communication - * target, NULL if there is no such endpoint registered. - * @note Assumes that the internal mutex is locked. - */ -static endpoint_t * find_locked(usb_bus_t *instance, - usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction) -{ - assert(instance); - assert(fibril_mutex_is_locked(&instance->guard)); - if (address < 0) - return NULL; - list_foreach(*get_list(instance, address), link, endpoint_t, ep) { - if (ep_match(ep, address, endpoint, direction)) - return ep; - } - return NULL; -} - -/** Get a free USB address - * - * @param[in] instance Device manager structure to use. - * @return Free address, or error code. - */ -static usb_address_t usb_bus_get_free_address(usb_bus_t *instance) -{ - - usb_address_t new_address = instance->last_address; - do { - new_address = (new_address + 1) % USB_ADDRESS_COUNT; - if (new_address == USB_ADDRESS_DEFAULT) - new_address = 1; - if (new_address == instance->last_address) - return ENOSPC; - } while (instance->devices[new_address].occupied); - - assert(new_address != USB_ADDRESS_DEFAULT); - instance->last_address = new_address; - - return new_address; -} - -/** Calculate bandwidth that needs to be reserved for communication with EP. - * Calculation follows USB 1.1 specification. - * @param speed Device's speed. - * @param type Type of the transfer. - * @param size Number of byte to transfer. - * @param max_packet_size Maximum bytes in one packet. - */ -size_t bandwidth_count_usb11(usb_speed_t speed, usb_transfer_type_t type, - size_t size, size_t max_packet_size) -{ - /* We care about bandwidth only for interrupt and isochronous. */ - if ((type != USB_TRANSFER_INTERRUPT) - && (type != USB_TRANSFER_ISOCHRONOUS)) { - return 0; - } - - const unsigned packet_count = - (size + max_packet_size - 1) / max_packet_size; - /* TODO: It may be that ISO and INT transfers use only one packet per - * transaction, but I did not find text in USB spec to confirm this */ - /* NOTE: All data packets will be considered to be max_packet_size */ - switch (speed) - { - case USB_SPEED_LOW: - assert(type == USB_TRANSFER_INTERRUPT); - /* Protocol overhead 13B - * (3 SYNC bytes, 3 PID bytes, 2 Endpoint + CRC bytes, 2 - * CRC bytes, and a 3-byte interpacket delay) - * see USB spec page 45-46. */ - /* Speed penalty 8: low speed is 8-times slower*/ - return packet_count * (13 + max_packet_size) * 8; - case USB_SPEED_FULL: - /* Interrupt transfer overhead see above - * or page 45 of USB spec */ - if (type == USB_TRANSFER_INTERRUPT) - return packet_count * (13 + max_packet_size); - - assert(type == USB_TRANSFER_ISOCHRONOUS); - /* Protocol overhead 9B - * (2 SYNC bytes, 2 PID bytes, 2 Endpoint + CRC bytes, 2 CRC - * bytes, and a 1-byte interpacket delay) - * see USB spec page 42 */ - return packet_count * (9 + max_packet_size); - default: - return 0; - } -} - -/** Calculate bandwidth that needs to be reserved for communication with EP. - * Calculation follows USB 2.0 specification. - * @param speed Device's speed. - * @param type Type of the transfer. - * @param size Number of byte to transfer. - * @param max_packet_size Maximum bytes in one packet. - */ -size_t bandwidth_count_usb20(usb_speed_t speed, usb_transfer_type_t type, - size_t size, size_t max_packet_size) -{ - /* We care about bandwidth only for interrupt and isochronous. */ - if ((type != USB_TRANSFER_INTERRUPT) - && (type != USB_TRANSFER_ISOCHRONOUS)) { - return 0; - } - //TODO Implement - return 0; -} - -/** Initialize to default state. - * You need to provide valid bw_count function if you plan to use - * add_endpoint/remove_endpoint pair. - * - * @param instance usb_bus structure, non-null. - * @param available_bandwidth Size of the bandwidth pool. - * @param bw_count function to use to calculate endpoint bw requirements. - * @return Error code. - */ -int usb_bus_init(usb_bus_t *instance, - size_t available_bandwidth, bw_count_func_t bw_count, usb_speed_t max_speed) -{ - assert(instance); - fibril_mutex_initialize(&instance->guard); - instance->free_bw = available_bandwidth; - instance->bw_count = bw_count; - instance->last_address = 0; - instance->max_speed = max_speed; - for (unsigned i = 0; i < ARRAY_SIZE(instance->devices); ++i) { - list_initialize(&instance->devices[i].endpoint_list); - instance->devices[i].speed = USB_SPEED_MAX; - instance->devices[i].occupied = false; - } - return EOK; -} - -/** Register endpoint structure. - * Checks for duplicates. - * @param instance usb_bus, non-null. - * @param ep endpoint_t to register. - * @param data_size Size of data to transfer. - * @return Error code. - */ -int usb_bus_register_ep(usb_bus_t *instance, endpoint_t *ep, size_t data_size) -{ - assert(instance); - if (ep == NULL || ep->address < 0) - return EINVAL; - - fibril_mutex_lock(&instance->guard); - /* Check for available bandwidth */ - if (ep->bandwidth > instance->free_bw) { - fibril_mutex_unlock(&instance->guard); - return ENOSPC; - } - - /* Check for existence */ - const endpoint_t *endpoint = - find_locked(instance, ep->address, ep->endpoint, ep->direction); - if (endpoint != NULL) { - fibril_mutex_unlock(&instance->guard); - return EEXIST; - } - /* Add endpoint list's reference to ep. */ - endpoint_add_ref(ep); - list_append(&ep->link, get_list(instance, ep->address)); - - instance->free_bw -= ep->bandwidth; - usb_log_debug("Registered EP(%d:%d:%s:%s)\n", ep->address, ep->endpoint, - usb_str_transfer_type_short(ep->transfer_type), - usb_str_direction(ep->direction)); - fibril_mutex_unlock(&instance->guard); - return EOK; -} - -/** Unregister endpoint structure. - * Checks for duplicates. - * @param instance usb_bus, non-null. - * @param ep endpoint_t to unregister. - * @return Error code. - */ -int usb_bus_unregister_ep(usb_bus_t *instance, endpoint_t *ep) -{ - assert(instance); - if (ep == NULL || ep->address < 0) - return EINVAL; - - fibril_mutex_lock(&instance->guard); - if (!list_member(&ep->link, get_list(instance, ep->address))) { - fibril_mutex_unlock(&instance->guard); - return ENOENT; - } - list_remove(&ep->link); - instance->free_bw += ep->bandwidth; - usb_log_debug("Unregistered EP(%d:%d:%s:%s)\n", ep->address, - ep->endpoint, usb_str_transfer_type_short(ep->transfer_type), - usb_str_direction(ep->direction)); - /* Drop endpoint list's reference to ep. */ - endpoint_del_ref(ep); - fibril_mutex_unlock(&instance->guard); - return EOK; -} - -/** Find endpoint_t representing the given communication route. - * @param instance usb_bus, non-null. - * @param address - */ -endpoint_t * usb_bus_find_ep(usb_bus_t *instance, - usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction) -{ - assert(instance); - - fibril_mutex_lock(&instance->guard); - endpoint_t *ep = find_locked(instance, address, endpoint, direction); - if (ep) { - /* We are exporting ep to the outside world, add reference. */ - endpoint_add_ref(ep); - } - fibril_mutex_unlock(&instance->guard); - return ep; -} - -/** Create and register new endpoint_t structure. - * @param instance usb_bus structure, non-null. - * @param address USB address. - * @param endpoint USB endpoint number. - * @param direction Communication direction. - * @param type USB transfer type. - * @param speed USB Communication speed. - * @param max_packet_size Maximum size of data packets. - * @param data_size Expected communication size. - * @param callback function to call just after registering. - * @param arg Argument to pass to the callback function. - * @return Error code. - */ -int usb_bus_add_ep(usb_bus_t *instance, - usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction, - usb_transfer_type_t type, size_t max_packet_size, unsigned packets, - size_t data_size, ep_add_callback_t callback, void *arg, - usb_address_t tt_address, unsigned tt_port) -{ - assert(instance); - if (instance->bw_count == NULL) - return ENOTSUP; - if (!usb_address_is_valid(address)) - return EINVAL; - - - fibril_mutex_lock(&instance->guard); - /* Check for speed and address */ - if (!instance->devices[address].occupied) { - fibril_mutex_unlock(&instance->guard); - return ENOENT; - } - - /* Check for existence */ - endpoint_t *ep = find_locked(instance, address, endpoint, direction); - if (ep != NULL) { - fibril_mutex_unlock(&instance->guard); - return EEXIST; - } - - const usb_speed_t speed = instance->devices[address].speed; - const size_t bw = - instance->bw_count(speed, type, data_size, max_packet_size); - - /* Check for available bandwidth */ - if (bw > instance->free_bw) { - fibril_mutex_unlock(&instance->guard); - return ENOSPC; - } - - ep = endpoint_create(address, endpoint, direction, type, speed, - max_packet_size, packets, bw, tt_address, tt_port); - if (!ep) { - fibril_mutex_unlock(&instance->guard); - return ENOMEM; - } - - /* Add our reference to ep. */ - endpoint_add_ref(ep); - - if (callback) { - const int ret = callback(ep, arg); - if (ret != EOK) { - fibril_mutex_unlock(&instance->guard); - endpoint_del_ref(ep); - return ret; - } - } - - /* Add endpoint list's reference to ep. */ - endpoint_add_ref(ep); - list_append(&ep->link, get_list(instance, ep->address)); - - instance->free_bw -= ep->bandwidth; - fibril_mutex_unlock(&instance->guard); - - /* Drop our reference to ep. */ - endpoint_del_ref(ep); - - return EOK; -} - -/** Unregister and destroy endpoint_t structure representing given route. - * @param instance usb_bus structure, non-null. - * @param address USB address. - * @param endpoint USB endpoint number. - * @param direction Communication direction. - * @param callback Function to call after unregister, before destruction. - * @arg Argument to pass to the callback function. - * @return Error code. - */ -int usb_bus_remove_ep(usb_bus_t *instance, - usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction, - ep_remove_callback_t callback, void *arg) -{ - assert(instance); - fibril_mutex_lock(&instance->guard); - endpoint_t *ep = find_locked(instance, address, endpoint, direction); - if (ep != NULL) { - list_remove(&ep->link); - instance->free_bw += ep->bandwidth; - } - fibril_mutex_unlock(&instance->guard); - if (ep == NULL) - return ENOENT; - - if (callback) { - callback(ep, arg); - } - /* Drop endpoint list's reference to ep. */ - endpoint_del_ref(ep); - return EOK; -} - -int usb_bus_reset_toggle(usb_bus_t *instance, usb_target_t target, bool all) -{ - assert(instance); - if (!usb_target_is_valid(target)) - return EINVAL; - - int ret = ENOENT; - - fibril_mutex_lock(&instance->guard); - list_foreach(*get_list(instance, target.address), link, endpoint_t, ep) { - if ((ep->address == target.address) - && (all || ep->endpoint == target.endpoint)) { - endpoint_toggle_set(ep, 0); - ret = EOK; - } - } - fibril_mutex_unlock(&instance->guard); - return ret; -} - -/** Unregister and destroy all endpoints using given address. - * @param instance usb_bus structure, non-null. - * @param address USB address. - * @param endpoint USB endpoint number. - * @param direction Communication direction. - * @param callback Function to call after unregister, before destruction. - * @arg Argument to pass to the callback function. - * @return Error code. - */ -int usb_bus_remove_address(usb_bus_t *instance, - usb_address_t address, ep_remove_callback_t callback, void *arg) -{ - assert(instance); - if (!usb_address_is_valid(address)) - return EINVAL; - - fibril_mutex_lock(&instance->guard); - - const int ret = instance->devices[address].occupied ? EOK : ENOENT; - instance->devices[address].occupied = false; - - list_t *list = get_list(instance, address); - for (link_t *link = list_first(list); link != NULL; ) { - endpoint_t *ep = list_get_instance(link, endpoint_t, link); - link = list_next(link, list); - if (ep->address == address) { - list_remove(&ep->link); - if (callback) - callback(ep, arg); - /* Drop endpoint list's reference to ep. */ - endpoint_del_ref(ep); - } - } - fibril_mutex_unlock(&instance->guard); - return ret; -} - -/** Request USB address. - * @param instance usb_device_manager - * @param address Pointer to requested address value, place to store new address - * @parma strict Fail if the requested address is not available. - * @return Error code. - * @note Default address is only available in strict mode. - */ -int usb_bus_request_address(usb_bus_t *instance, - usb_address_t *address, bool strict, usb_speed_t speed) -{ - assert(instance); - assert(address); - if (speed > instance->max_speed) - return ENOTSUP; - - if (!usb_address_is_valid(*address)) - return EINVAL; - - usb_address_t addr = *address; - - fibril_mutex_lock(&instance->guard); - /* Only grant default address to strict requests */ - if ((addr == USB_ADDRESS_DEFAULT) && !strict) { - addr = usb_bus_get_free_address(instance); - } - - if (instance->devices[addr].occupied) { - if (strict) { - fibril_mutex_unlock(&instance->guard); - return ENOENT; - } - addr = usb_bus_get_free_address(instance); - } - if (usb_address_is_valid(addr)) { - assert(instance->devices[addr].occupied == false); - assert(addr != USB_ADDRESS_DEFAULT || strict); - - instance->devices[addr].occupied = true; - instance->devices[addr].speed = speed; - *address = addr; - addr = 0; - } - - fibril_mutex_unlock(&instance->guard); - return addr; -} - -/** Get speed assigned to USB address. - * - * @param[in] instance Device manager structure to use. - * @param[in] address Address the caller wants to find. - * @param[out] speed Assigned speed. - * @return Error code. - */ -int usb_bus_get_speed(usb_bus_t *instance, usb_address_t address, - usb_speed_t *speed) -{ - assert(instance); - if (!usb_address_is_valid(address)) { - return EINVAL; - } - - fibril_mutex_lock(&instance->guard); - - const int ret = instance->devices[address].occupied ? EOK : ENOENT; - if (speed && instance->devices[address].occupied) { - *speed = instance->devices[address].speed; - } - - fibril_mutex_unlock(&instance->guard); - return ret; -} -/** - * @} - */