Changeset 747ef72 in mainline for uspace/lib/usbhost/src/iface.c


Ignore:
Timestamp:
2011-11-10T11:29:10Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
54464f6a, c2245a3, c6f189f7
Parents:
2e1b9dc (diff), 2d1ba51 (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 USB changes.

Interface changes:

  • GET_ADDRESS has been renamed to GET_MY_ADDRESS and the handle parameter was dropped. Tis call no longer cascades up to the root hub, but it is answered in the first place the information is available (nearest hub)
  • Reintroduced address reservation for USB_DEFAULT_ADDRESS. The interface now enables device drivers to request specific address on initialization and either insists on that address or accept any other if the address is not available. Note that it is not possible to get the default address if the driver does not insist.
  • Any endpoint registered is removed when address is released and a warning is produced if there were any such endpoints.
  • It is no longer necessary or possible to pass device speed information when registering endpoints.

Driver fixes: memory leaks and crashes (not only) in error paths.
Fixes or removes flaky device_remove implementation in device drivers.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r2e1b9dc r747ef72  
    8989}
    9090/*----------------------------------------------------------------------------*/
    91 /** Request address interface function
    92  *
    93  * @param[in] fun DDF function that was called.
    94  * @param[in] speed Speed to associate with the new default address.
    95  * @param[out] address Place to write a new address.
    96  * @return Error code.
    97  */
    98 static int request_address(
    99     ddf_fun_t *fun, usb_speed_t speed, usb_address_t *address)
    100 {
    101         assert(fun);
    102         hcd_t *hcd = fun_to_hcd(fun);
    103         assert(hcd);
    104         assert(address);
    105 
    106         usb_log_debug("Address request speed: %s.\n", usb_str_speed(speed));
    107         *address =
    108             usb_device_manager_get_free_address(&hcd->dev_manager, speed);
    109         usb_log_debug("Address request with result: %d.\n", *address);
    110         if (*address <= 0)
    111                 return *address;
    112         return EOK;
    113 }
    114 /*----------------------------------------------------------------------------*/
    115 /** Bind address interface function
    116  *
    117  * @param[in] fun DDF function that was called.
    118  * @param[in] address Address of the device
    119  * @param[in] handle Devman handle of the device driver.
    120  * @return Error code.
    121  */
    122 static int bind_address(
    123   ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
    124 {
    125         assert(fun);
    126         hcd_t *hcd = fun_to_hcd(fun);
    127         assert(hcd);
    128 
    129         usb_log_debug("Address bind %d-%" PRIun ".\n", address, handle);
    130         return usb_device_manager_bind(&hcd->dev_manager, address, handle);
    131 }
    132 /*----------------------------------------------------------------------------*/
    133 /** Find device handle by address interface function.
    134  *
    135  * @param[in] fun DDF function that was called.
    136  * @param[in] address Address in question.
    137  * @param[out] handle Where to store device handle if found.
    138  * @return Error code.
    139  */
    140 static int find_by_address(ddf_fun_t *fun, usb_address_t address,
    141     devman_handle_t *handle)
    142 {
    143         assert(fun);
    144         hcd_t *hcd = fun_to_hcd(fun);
    145         assert(hcd);
    146         return usb_device_manager_get_info_by_address(
    147             &hcd->dev_manager, address, handle, NULL);
    148 }
    149 /*----------------------------------------------------------------------------*/
    150 /** Release address interface function
    151  *
    152  * @param[in] fun DDF function that was called.
    153  * @param[in] address USB address to be released.
    154  * @return Error code.
    155  */
    156 static int release_address(ddf_fun_t *fun, usb_address_t address)
    157 {
    158         assert(fun);
    159         hcd_t *hcd = fun_to_hcd(fun);
    160         assert(hcd);
    161         usb_log_debug("Address release %d.\n", address);
    162         usb_device_manager_release(&hcd->dev_manager, address);
    163         return EOK;
    164 }
    165 /*----------------------------------------------------------------------------*/
    16691static int register_helper(endpoint_t *ep, void *arg)
    16792{
    … …  
    183108}
    184109/*----------------------------------------------------------------------------*/
     110static void unregister_helper_warn(endpoint_t *ep, void *arg)
     111{
     112        hcd_t *hcd = arg;
     113        assert(ep);
     114        assert(hcd);
     115        usb_log_warning("Endpoint %d:%d %s was left behind, removing.\n",
     116            ep->address, ep->endpoint, usb_str_direction(ep->direction));
     117        if (hcd->ep_remove_hook)
     118                hcd->ep_remove_hook(hcd, ep);
     119}
     120/*----------------------------------------------------------------------------*/
     121/** Request address interface function
     122 *
     123 * @param[in] fun DDF function that was called.
     124 * @param[in] speed Speed to associate with the new default address.
     125 * @param[out] address Place to write a new address.
     126 * @return Error code.
     127 */
     128static int request_address(
     129    ddf_fun_t *fun, usb_address_t *address, bool strict, usb_speed_t speed)
     130{
     131        assert(fun);
     132        hcd_t *hcd = fun_to_hcd(fun);
     133        assert(hcd);
     134        assert(address);
     135
     136        usb_log_debug("Address request: speed: %s, address: %d, strict: %s.\n",
     137            usb_str_speed(speed), *address, strict ? "YES" : "NO");
     138        return usb_device_manager_request_address(
     139            &hcd->dev_manager, address, strict, speed);
     140}
     141/*----------------------------------------------------------------------------*/
     142/** Bind address interface function
     143 *
     144 * @param[in] fun DDF function that was called.
     145 * @param[in] address Address of the device
     146 * @param[in] handle Devman handle of the device driver.
     147 * @return Error code.
     148 */
     149static int bind_address(
     150  ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
     151{
     152        assert(fun);
     153        hcd_t *hcd = fun_to_hcd(fun);
     154        assert(hcd);
     155
     156        usb_log_debug("Address bind %d-%" PRIun ".\n", address, handle);
     157        return usb_device_manager_bind_address(
     158            &hcd->dev_manager, address, handle);
     159}
     160/*----------------------------------------------------------------------------*/
     161/** Find device handle by address interface function.
     162 *
     163 * @param[in] fun DDF function that was called.
     164 * @param[in] address Address in question.
     165 * @param[out] handle Where to store device handle if found.
     166 * @return Error code.
     167 */
     168static int find_by_address(ddf_fun_t *fun, usb_address_t address,
     169    devman_handle_t *handle)
     170{
     171        assert(fun);
     172        hcd_t *hcd = fun_to_hcd(fun);
     173        assert(hcd);
     174        return usb_device_manager_get_info_by_address(
     175            &hcd->dev_manager, address, handle, NULL);
     176}
     177/*----------------------------------------------------------------------------*/
     178/** Release address interface function
     179 *
     180 * @param[in] fun DDF function that was called.
     181 * @param[in] address USB address to be released.
     182 * @return Error code.
     183 */
     184static int release_address(ddf_fun_t *fun, usb_address_t address)
     185{
     186        assert(fun);
     187        hcd_t *hcd = fun_to_hcd(fun);
     188        assert(hcd);
     189        usb_log_debug("Address release %d.\n", address);
     190        usb_device_manager_release_address(&hcd->dev_manager, address);
     191        usb_endpoint_manager_remove_address(&hcd->ep_manager, address,
     192            unregister_helper_warn, hcd);
     193        return EOK;
     194}
     195/*----------------------------------------------------------------------------*/
    185196static int register_endpoint(
    186     ddf_fun_t *fun, usb_address_t address, usb_speed_t ep_speed,
    187     usb_endpoint_t endpoint,
     197    ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
    188198    usb_transfer_type_t transfer_type, usb_direction_t direction,
    189199    size_t max_packet_size, unsigned int interval)
    … …  
    193203        assert(hcd);
    194204        const size_t size = max_packet_size;
    195         /* Default address is not bound or registered,
    196          * thus it does not provide speed info. */
    197         usb_speed_t speed = ep_speed;
    198         /* NOTE The function will return EINVAL and won't
    199          * touch speed variable for default address */
    200         usb_device_manager_get_info_by_address(
     205        usb_speed_t speed = USB_SPEED_MAX;
     206        const int ret = usb_device_manager_get_info_by_address(
    201207            &hcd->dev_manager, address, NULL, &speed);
     208        if (ret != EOK) {
     209                return ret;
     210        }
    202211
    203212        usb_log_debug("Register endpoint %d:%d %s-%s %s %zuB %ums.\n",
Note: See TracChangeset for help on using the changeset viewer.