Changes in / [a9d67aa:5410c04] in mainline


Ignore:
Location:
uspace
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ehci-hcd/hc_iface.c

    ra9d67aa r5410c04  
    123123 * @param[in] fun Device function the action was invoked on.
    124124 * @param[in] address USB address of the device.
    125  * @param[in] speed Endpoint speed (invalid means to use device one).
    126125 * @param[in] endpoint Endpoint number.
    127126 * @param[in] transfer_type USB transfer type.
    … …  
    132131 */
    133132static int register_endpoint(ddf_fun_t *fun,
    134     usb_address_t address, usb_speed_t speed, usb_endpoint_t endpoint,
     133    usb_address_t address, usb_endpoint_t endpoint,
    135134    usb_transfer_type_t transfer_type, usb_direction_t direction,
    136135    size_t max_packet_size, unsigned int interval)
    … …  
    166165 * @param[in] fun Device function the action was invoked on.
    167166 * @param[in] target Target pipe (address and endpoint number) specification.
     167 * @param[in] max_packet_size Max packet size for the transfer.
    168168 * @param[in] data Data to be sent (in USB endianess, allocated and deallocated
    169169 *      by the caller).
    … …  
    174174 */
    175175static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
    176     void *data, size_t size,
     176    size_t max_packet_size, void *data, size_t size,
    177177    usbhc_iface_transfer_out_callback_t callback, void *arg)
    178178{
    … …  
    191191 * @param[in] fun Device function the action was invoked on.
    192192 * @param[in] target Target pipe (address and endpoint number) specification.
     193 * @param[in] max_packet_size Max packet size for the transfer.
    193194 * @param[in] data Buffer where to store the data (in USB endianess,
    194195 *      allocated and deallocated by the caller).
    … …  
    199200 */
    200201static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
    201     void *data, size_t size,
     202    size_t max_packet_size, void *data, size_t size,
    202203    usbhc_iface_transfer_in_callback_t callback, void *arg)
    203204{
    … …  
    216217 * @param[in] fun Device function the action was invoked on.
    217218 * @param[in] target Target pipe (address and endpoint number) specification.
     219 * @param[in] max_packet_size Max packet size for the transfer.
    218220 * @param[in] data Data to be sent (in USB endianess, allocated and deallocated
    219221 *      by the caller).
    … …  
    224226 */
    225227static int bulk_out(ddf_fun_t *fun, usb_target_t target,
    226     void *data, size_t size,
     228    size_t max_packet_size, void *data, size_t size,
    227229    usbhc_iface_transfer_out_callback_t callback, void *arg)
    228230{
    … …  
    241243 * @param[in] fun Device function the action was invoked on.
    242244 * @param[in] target Target pipe (address and endpoint number) specification.
     245 * @param[in] max_packet_size Max packet size for the transfer.
    243246 * @param[in] data Buffer where to store the data (in USB endianess,
    244247 *      allocated and deallocated by the caller).
    … …  
    249252 */
    250253static int bulk_in(ddf_fun_t *fun, usb_target_t target,
    251     void *data, size_t size,
     254    size_t max_packet_size, void *data, size_t size,
    252255    usbhc_iface_transfer_in_callback_t callback, void *arg)
    253256{
    … …  
    266269 * @param[in] fun Device function the action was invoked on.
    267270 * @param[in] target Target pipe (address and endpoint number) specification.
     271 * @param[in] max_packet_size Max packet size for the transfer.
    268272 * @param[in] setup_packet Setup packet buffer (in USB endianess, allocated
    269273 *      and deallocated by the caller).
    … …  
    277281 */
    278282static int control_write(ddf_fun_t *fun, usb_target_t target,
     283    size_t max_packet_size,
    279284    void *setup_packet, size_t setup_packet_size,
    280285    void *data_buffer, size_t data_buffer_size,
    … …  
    295300 * @param[in] fun Device function the action was invoked on.
    296301 * @param[in] target Target pipe (address and endpoint number) specification.
     302 * @param[in] max_packet_size Max packet size for the transfer.
    297303 * @param[in] setup_packet Setup packet buffer (in USB endianess, allocated
    298304 *      and deallocated by the caller).
    … …  
    306312 */
    307313static int control_read(ddf_fun_t *fun, usb_target_t target,
     314    size_t max_packet_size,
    308315    void *setup_packet, size_t setup_packet_size,
    309316    void *data_buffer, size_t data_buffer_size,

  • uspace/drv/ohci/iface.c

    ra9d67aa r5410c04  
    197197}
    198198/*----------------------------------------------------------------------------*/
    199 /** Register endpoint for bandwidth reservation.
    200  *
    201  * @param[in] fun Device function the action was invoked on.
    202  * @param[in] address USB address of the device.
    203  * @param[in] ep_speed Endpoint speed (invalid means to use device one).
    204  * @param[in] endpoint Endpoint number.
    205  * @param[in] transfer_type USB transfer type.
    206  * @param[in] direction Endpoint data direction.
    207  * @param[in] max_packet_size Max packet size of the endpoint.
    208  * @param[in] interval Polling interval.
    209  * @return Error code.
    210  */
    211 static int register_endpoint(ddf_fun_t *fun,
    212     usb_address_t address, usb_speed_t ep_speed, usb_endpoint_t endpoint,
     199static int register_endpoint(
     200    ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
    213201    usb_transfer_type_t transfer_type, usb_direction_t direction,
    214202    size_t max_packet_size, unsigned int interval)
    … …  
    216204        hc_t *hc = fun_to_hc(fun);
    217205        assert(hc);
    218         if (address == hc->rh.address)
    219                 return EOK;
    220         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, address);
    221         if (speed >= USB_SPEED_MAX) {
    222                 speed = ep_speed;
    223         }
     206        const usb_speed_t speed =
     207            usb_device_keeper_get_speed(&hc->manager, address);
    224208        const size_t size =
    225209            (transfer_type == USB_TRANSFER_INTERRUPT
    … …  
    259243        usb_log_debug("Unregister endpoint %d:%d %d.\n",
    260244            address, endpoint, direction);
    261         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    262             address, endpoint, direction, NULL);
    263         if (ep != NULL) {
    264                 usb_device_keeper_del_ep(&hc->manager, address, ep);
    265         }
    266245        return usb_endpoint_manager_unregister_ep(&hc->ep_manager, address,
    267246            endpoint, direction);
    268247}
    269248/*----------------------------------------------------------------------------*/
    270 /** Schedule interrupt out transfer.
    271  *
    272  * The callback is supposed to be called once the transfer (on the wire) is
    273  * complete regardless of the outcome.
    274  * However, the callback could be called only when this function returns
    275  * with success status (i.e. returns EOK).
    276  *
    277  * @param[in] fun Device function the action was invoked on.
    278  * @param[in] target Target pipe (address and endpoint number) specification.
    279  * @param[in] data Data to be sent (in USB endianess, allocated and deallocated
    280  *      by the caller).
    281  * @param[in] size Size of the @p data buffer in bytes.
    282  * @param[in] callback Callback to be issued once the transfer is complete.
    283  * @param[in] arg Pass-through argument to the callback.
     249/** Interrupt out transaction interface function
     250 *
     251 * @param[in] fun DDF function that was called.
     252 * @param[in] target USB device to write to.
     253 * @param[in] max_packet_size maximum size of data packet the device accepts
     254 * @param[in] data Source of data.
     255 * @param[in] size Size of data source.
     256 * @param[in] callback Function to call on transaction completion
     257 * @param[in] arg Additional for callback function.
    284258 * @return Error code.
    285259 */
    286260static int interrupt_out(
    287     ddf_fun_t *fun, usb_target_t target, void *data,
     261    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    288262    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    289263{
    … …  
    302276}
    303277/*----------------------------------------------------------------------------*/
    304 /** Schedule interrupt in transfer.
    305  *
    306  * The callback is supposed to be called once the transfer (on the wire) is
    307  * complete regardless of the outcome.
    308  * However, the callback could be called only when this function returns
    309  * with success status (i.e. returns EOK).
    310  *
    311  * @param[in] fun Device function the action was invoked on.
    312  * @param[in] target Target pipe (address and endpoint number) specification.
    313  * @param[in] data Buffer where to store the data (in USB endianess,
    314  *      allocated and deallocated by the caller).
    315  * @param[in] size Size of the @p data buffer in bytes.
    316  * @param[in] callback Callback to be issued once the transfer is complete.
    317  * @param[in] arg Pass-through argument to the callback.
     278/** Interrupt in transaction interface function
     279 *
     280 * @param[in] fun DDF function that was called.
     281 * @param[in] target USB device to write to.
     282 * @param[in] max_packet_size maximum size of data packet the device accepts
     283 * @param[out] data Data destination.
     284 * @param[in] size Size of data source.
     285 * @param[in] callback Function to call on transaction completion
     286 * @param[in] arg Additional for callback function.
    318287 * @return Error code.
    319288 */
    320289static int interrupt_in(
    321     ddf_fun_t *fun, usb_target_t target, void *data,
     290    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    322291    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    323292{
    … …  
    336305}
    337306/*----------------------------------------------------------------------------*/
    338 /** Schedule bulk out transfer.
    339  *
    340  * The callback is supposed to be called once the transfer (on the wire) is
    341  * complete regardless of the outcome.
    342  * However, the callback could be called only when this function returns
    343  * with success status (i.e. returns EOK).
    344  *
    345  * @param[in] fun Device function the action was invoked on.
    346  * @param[in] target Target pipe (address and endpoint number) specification.
    347  * @param[in] data Data to be sent (in USB endianess, allocated and deallocated
    348  *      by the caller).
    349  * @param[in] size Size of the @p data buffer in bytes.
    350  * @param[in] callback Callback to be issued once the transfer is complete.
    351  * @param[in] arg Pass-through argument to the callback.
     307/** Bulk out transaction interface function
     308 *
     309 * @param[in] fun DDF function that was called.
     310 * @param[in] target USB device to write to.
     311 * @param[in] max_packet_size maximum size of data packet the device accepts
     312 * @param[in] data Source of data.
     313 * @param[in] size Size of data source.
     314 * @param[in] callback Function to call on transaction completion
     315 * @param[in] arg Additional for callback function.
    352316 * @return Error code.
    353317 */
    354318static int bulk_out(
    355     ddf_fun_t *fun, usb_target_t target, void *data,
     319    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    356320    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    357321{
    … …  
    370334}
    371335/*----------------------------------------------------------------------------*/
    372 /** Schedule bulk in transfer.
    373  *
    374  * The callback is supposed to be called once the transfer (on the wire) is
    375  * complete regardless of the outcome.
    376  * However, the callback could be called only when this function returns
    377  * with success status (i.e. returns EOK).
    378  *
    379  * @param[in] fun Device function the action was invoked on.
    380  * @param[in] target Target pipe (address and endpoint number) specification.
    381  * @param[in] data Buffer where to store the data (in USB endianess,
    382  *      allocated and deallocated by the caller).
    383  * @param[in] size Size of the @p data buffer in bytes.
    384  * @param[in] callback Callback to be issued once the transfer is complete.
    385  * @param[in] arg Pass-through argument to the callback.
     336/** Bulk in transaction interface function
     337 *
     338 * @param[in] fun DDF function that was called.
     339 * @param[in] target USB device to write to.
     340 * @param[in] max_packet_size maximum size of data packet the device accepts
     341 * @param[out] data Data destination.
     342 * @param[in] size Size of data source.
     343 * @param[in] callback Function to call on transaction completion
     344 * @param[in] arg Additional for callback function.
    386345 * @return Error code.
    387346 */
    388347static int bulk_in(
    389     ddf_fun_t *fun, usb_target_t target, void *data,
     348    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    390349    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    391350{
    … …  
    404363}
    405364/*----------------------------------------------------------------------------*/
    406 /** Schedule control write transfer.
    407  *
    408  * The callback is supposed to be called once the transfer (on the wire) is
    409  * complete regardless of the outcome.
    410  * However, the callback could be called only when this function returns
    411  * with success status (i.e. returns EOK).
    412  *
    413  * @param[in] fun Device function the action was invoked on.
    414  * @param[in] target Target pipe (address and endpoint number) specification.
    415  * @param[in] setup_packet Setup packet buffer (in USB endianess, allocated
    416  *      and deallocated by the caller).
    417  * @param[in] setup_packet_size Size of @p setup_packet buffer in bytes.
    418  * @param[in] data_buffer Data buffer (in USB endianess, allocated and
    419  *      deallocated by the caller).
    420  * @param[in] data_buffer_size Size of @p data_buffer buffer in bytes.
    421  * @param[in] callback Callback to be issued once the transfer is complete.
    422  * @param[in] arg Pass-through argument to the callback.
     365/** Control write transaction interface function
     366 *
     367 * @param[in] fun DDF function that was called.
     368 * @param[in] target USB device to write to.
     369 * @param[in] max_packet_size maximum size of data packet the device accepts.
     370 * @param[in] setup_data Data to send with SETUP transfer.
     371 * @param[in] setup_size Size of data to send with SETUP transfer (always 8B).
     372 * @param[in] data Source of data.
     373 * @param[in] size Size of data source.
     374 * @param[in] callback Function to call on transaction completion.
     375 * @param[in] arg Additional for callback function.
    423376 * @return Error code.
    424377 */
    425378static int control_write(
    426     ddf_fun_t *fun, usb_target_t target,
     379    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
    427380    void *setup_data, size_t setup_size, void *data, size_t size,
    428381    usbhc_iface_transfer_out_callback_t callback, void *arg)
    … …  
    444397}
    445398/*----------------------------------------------------------------------------*/
    446 /** Schedule control read transfer.
    447  *
    448  * The callback is supposed to be called once the transfer (on the wire) is
    449  * complete regardless of the outcome.
    450  * However, the callback could be called only when this function returns
    451  * with success status (i.e. returns EOK).
    452  *
    453  * @param[in] fun Device function the action was invoked on.
    454  * @param[in] target Target pipe (address and endpoint number) specification.
    455  * @param[in] setup_packet Setup packet buffer (in USB endianess, allocated
    456  *      and deallocated by the caller).
    457  * @param[in] setup_packet_size Size of @p setup_packet buffer in bytes.
    458  * @param[in] data_buffer Buffer where to store the data (in USB endianess,
    459  *      allocated and deallocated by the caller).
    460  * @param[in] data_buffer_size Size of @p data_buffer buffer in bytes.
    461  * @param[in] callback Callback to be issued once the transfer is complete.
    462  * @param[in] arg Pass-through argument to the callback.
     399/** Control read transaction interface function
     400 *
     401 * @param[in] fun DDF function that was called.
     402 * @param[in] target USB device to write to.
     403 * @param[in] max_packet_size maximum size of data packet the device accepts.
     404 * @param[in] setup_data Data to send with SETUP packet.
     405 * @param[in] setup_size Size of data to send with SETUP packet (should be 8B).
     406 * @param[out] data Source of data.
     407 * @param[in] size Size of data source.
     408 * @param[in] callback Function to call on transaction completion.
     409 * @param[in] arg Additional for callback function.
    463410 * @return Error code.
    464411 */
    465412static int control_read(
    466     ddf_fun_t *fun, usb_target_t target,
     413    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
    467414    void *setup_data, size_t setup_size, void *data, size_t size,
    468415    usbhc_iface_transfer_in_callback_t callback, void *arg)

  • uspace/drv/uhci-hcd/iface.c

    ra9d67aa r5410c04  
    7474            name, target.address, target.endpoint, size, ep->max_packet_size);
    7575
    76 //      assert(ep->speed ==
    77 //          usb_device_keeper_get_speed(&(*hc)->manager, target.address));
     76        assert(ep->speed ==
     77            usb_device_keeper_get_speed(&(*hc)->manager, target.address));
    7878//      assert(ep->max_packet_size == max_packet_size);
    7979//      assert(ep->transfer_type == USB_TRANSFER_CONTROL);
    … …  
    198198/*----------------------------------------------------------------------------*/
    199199static int register_endpoint(
    200     ddf_fun_t *fun, usb_address_t address, usb_speed_t ep_speed,
    201     usb_endpoint_t endpoint,
     200    ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
    202201    usb_transfer_type_t transfer_type, usb_direction_t direction,
    203202    size_t max_packet_size, unsigned int interval)
    … …  
    205204        hc_t *hc = fun_to_hc(fun);
    206205        assert(hc);
    207         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, address);
    208         if (speed >= USB_SPEED_MAX) {
    209                 speed = ep_speed;
    210         }
    211         const size_t size =
    212             (transfer_type == USB_TRANSFER_INTERRUPT
    213             || transfer_type == USB_TRANSFER_ISOCHRONOUS) ?
    214             max_packet_size : 0;
     206        const usb_speed_t speed =
     207            usb_device_keeper_get_speed(&hc->manager, address);
     208        const size_t size = max_packet_size;
    215209        int ret;
    216210
    … …  
    246240        usb_log_debug("Unregister endpoint %d:%d %d.\n",
    247241            address, endpoint, direction);
    248         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    249             address, endpoint, direction, NULL);
    250         if (ep != NULL) {
    251                 usb_device_keeper_del_ep(&hc->manager, address, ep);
    252         }
    253242        return usb_endpoint_manager_unregister_ep(&hc->ep_manager, address,
    254243            endpoint, direction);
    … …  
    259248 * @param[in] fun DDF function that was called.
    260249 * @param[in] target USB device to write to.
     250 * @param[in] max_packet_size maximum size of data packet the device accepts
    261251 * @param[in] data Source of data.
    262252 * @param[in] size Size of data source.
    … …  
    266256 */
    267257static int interrupt_out(
    268     ddf_fun_t *fun, usb_target_t target, void *data,
     258    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    269259    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    270260{
    … …  
    287277 * @param[in] fun DDF function that was called.
    288278 * @param[in] target USB device to write to.
     279 * @param[in] max_packet_size maximum size of data packet the device accepts
    289280 * @param[out] data Data destination.
    290281 * @param[in] size Size of data source.
    … …  
    294285 */
    295286static int interrupt_in(
    296     ddf_fun_t *fun, usb_target_t target, void *data,
     287    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    297288    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    298289{
    … …  
    315306 * @param[in] fun DDF function that was called.
    316307 * @param[in] target USB device to write to.
     308 * @param[in] max_packet_size maximum size of data packet the device accepts
    317309 * @param[in] data Source of data.
    318310 * @param[in] size Size of data source.
    … …  
    322314 */
    323315static int bulk_out(
    324     ddf_fun_t *fun, usb_target_t target, void *data,
     316    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    325317    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    326318{
    … …  
    343335 * @param[in] fun DDF function that was called.
    344336 * @param[in] target USB device to write to.
     337 * @param[in] max_packet_size maximum size of data packet the device accepts
    345338 * @param[out] data Data destination.
    346339 * @param[in] size Size of data source.
    … …  
    350343 */
    351344static int bulk_in(
    352     ddf_fun_t *fun, usb_target_t target, void *data,
     345    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
    353346    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    354347{
    … …  
    371364 * @param[in] fun DDF function that was called.
    372365 * @param[in] target USB device to write to.
     366 * @param[in] max_packet_size maximum size of data packet the device accepts.
    373367 * @param[in] setup_data Data to send with SETUP transfer.
    374368 * @param[in] setup_size Size of data to send with SETUP transfer (always 8B).
    … …  
    380374 */
    381375static int control_write(
    382     ddf_fun_t *fun, usb_target_t target,
     376    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
    383377    void *setup_data, size_t setup_size, void *data, size_t size,
    384378    usbhc_iface_transfer_out_callback_t callback, void *arg)
    … …  
    404398 * @param[in] fun DDF function that was called.
    405399 * @param[in] target USB device to write to.
     400 * @param[in] max_packet_size maximum size of data packet the device accepts.
    406401 * @param[in] setup_data Data to send with SETUP packet.
    407402 * @param[in] setup_size Size of data to send with SETUP packet (should be 8B).
    … …  
    413408 */
    414409static int control_read(
    415     ddf_fun_t *fun, usb_target_t target,
     410    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
    416411    void *setup_data, size_t setup_size, void *data, size_t size,
    417412    usbhc_iface_transfer_in_callback_t callback, void *arg)

  • uspace/drv/vhc/connhost.c

    ra9d67aa r5410c04  
    257257
    258258static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
     259    size_t max_packet_size,
    259260    void *data, size_t size,
    260261    usbhc_iface_transfer_out_callback_t callback, void *arg)
    … …  
    266267
    267268static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
     269    size_t max_packet_size,
    268270    void *data, size_t size,
    269271    usbhc_iface_transfer_in_callback_t callback, void *arg)
    … …  
    275277
    276278static int control_write(ddf_fun_t *fun, usb_target_t target,
     279    size_t max_packet_size,
    277280    void *setup_packet, size_t setup_packet_size,
    278281    void *data, size_t data_size,
    … …  
    292295
    293296static int control_read(ddf_fun_t *fun, usb_target_t target,
     297    size_t max_packet_size,
    294298    void *setup_packet, size_t setup_packet_size,
    295299    void *data, size_t data_size,

  • uspace/lib/drv/generic/remote_usbhc.c

    ra9d67aa r5410c04  
    270270        }
    271271
     272        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
    272273        usb_target_t target = {
    273274                .address = DEV_IPC_GET_ARG1(*call),
    … …  
    299300        trans->size = len;
    300301
    301         rc = transfer_func(fun, target,
     302        rc = transfer_func(fun, target, max_packet_size,
    302303            buffer, len,
    303304            callback_out, trans);
    … …  
    325326        }
    326327
     328        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
    327329        usb_target_t target = {
    328330                .address = DEV_IPC_GET_ARG1(*call),
    … …  
    346348        trans->size = len;
    347349
    348         int rc = transfer_func(fun, target,
     350        int rc = transfer_func(fun, target, max_packet_size,
    349351            trans->buffer, len,
    350352            callback_in, trans);
    … …  
    412414        };
    413415        size_t data_buffer_len = DEV_IPC_GET_ARG3(*call);
     416        size_t max_packet_size = DEV_IPC_GET_ARG4(*call);
    414417
    415418        int rc;
    … …  
    447450        trans->size = data_buffer_len;
    448451
    449         rc = usb_iface->control_write(fun, target,
     452        rc = usb_iface->control_write(fun, target, max_packet_size,
    450453            setup_packet, setup_packet_len,
    451454            data_buffer, data_buffer_len,
    … …  
    474477                .endpoint = DEV_IPC_GET_ARG2(*call)
    475478        };
     479        size_t max_packet_size = DEV_IPC_GET_ARG3(*call);
    476480
    477481        int rc;
    … …  
    511515        }
    512516
    513         rc = usb_iface->control_read(fun, target,
     517        rc = usb_iface->control_read(fun, target, max_packet_size,
    514518            setup_packet, setup_packet_len,
    515519            trans->buffer, trans->size,
    … …  
    533537        }
    534538
    535 #define _INIT_FROM_HIGH_DATA2(type, var, arg_no) \
    536         type var = (type) DEV_IPC_GET_ARG##arg_no(*call) / (1 << 16)
    537 #define _INIT_FROM_LOW_DATA2(type, var, arg_no) \
    538         type var = (type) DEV_IPC_GET_ARG##arg_no(*call) % (1 << 16)
    539 #define _INIT_FROM_HIGH_DATA3(type, var, arg_no) \
    540         type var = (type) DEV_IPC_GET_ARG##arg_no(*call) / (1 << 16)
    541 #define _INIT_FROM_MIDDLE_DATA3(type, var, arg_no) \
    542         type var = (type) (DEV_IPC_GET_ARG##arg_no(*call) / (1 << 8)) % (1 << 8)
    543 #define _INIT_FROM_LOW_DATA3(type, var, arg_no) \
    544         type var = (type) DEV_IPC_GET_ARG##arg_no(*call) % (1 << 8)
    545 
    546         _INIT_FROM_HIGH_DATA2(usb_address_t, address, 1);
    547         _INIT_FROM_LOW_DATA2(usb_endpoint_t, endpoint, 1);
    548 
    549         _INIT_FROM_HIGH_DATA3(usb_speed_t, speed, 2);
    550         _INIT_FROM_MIDDLE_DATA3(usb_transfer_type_t, transfer_type, 2);
    551         _INIT_FROM_LOW_DATA3(usb_direction_t, direction, 2);
    552 
    553         _INIT_FROM_HIGH_DATA2(size_t, max_packet_size, 3);
    554         _INIT_FROM_LOW_DATA2(unsigned int, interval, 3);
    555 
    556 #undef _INIT_FROM_HIGH_DATA2
    557 #undef _INIT_FROM_LOW_DATA2
    558 #undef _INIT_FROM_HIGH_DATA3
    559 #undef _INIT_FROM_MIDDLE_DATA3
    560 #undef _INIT_FROM_LOW_DATA3
    561 
    562         int rc = usb_iface->register_endpoint(fun, address, speed, endpoint,
     539#define INIT_FROM_HIGH_DATA(type, var, arg_no) \
     540        type var = (type) DEV_IPC_GET_ARG##arg_no(*call) / 256
     541#define INIT_FROM_LOW_DATA(type, var, arg_no) \
     542        type var = (type) DEV_IPC_GET_ARG##arg_no(*call) % 256
     543
     544        INIT_FROM_HIGH_DATA(usb_address_t, address, 1);
     545        INIT_FROM_LOW_DATA(usb_endpoint_t, endpoint, 1);
     546        INIT_FROM_HIGH_DATA(usb_transfer_type_t, transfer_type, 2);
     547        INIT_FROM_LOW_DATA(usb_direction_t, direction, 2);
     548
     549#undef INIT_FROM_HIGH_DATA
     550#undef INIT_FROM_LOW_DATA
     551
     552        size_t max_packet_size = (size_t) DEV_IPC_GET_ARG3(*call);
     553        unsigned int interval  = (unsigned int) DEV_IPC_GET_ARG4(*call);
     554
     555        int rc = usb_iface->register_endpoint(fun, address, endpoint,
    563556            transfer_type, direction, max_packet_size, interval);
    564557

  • uspace/lib/drv/include/usbhc_iface.h

    ra9d67aa r5410c04  
    6666 *   - argument #1 is target address
    6767 *   - argument #2 is target endpoint
     68 *   - argument #3 is max packet size of the endpoint
    6869 * - this call is immediately followed by IPC data read (async version)
    6970 * - the call is not answered until the device returns some data (or until
    … …  
    168169        /** Register endpoint attributes at host controller.
    169170         * This is used to reserve portion of USB bandwidth.
    170          * When speed is invalid, speed of the device is used.
    171171         * Parameters:
    172          * - USB address + endpoint number
    173          *   - packed as ADDR << 16 + EP
    174          * - speed + transfer type + direction
    175          *   - packed as ( SPEED << 8 + TYPE ) << 8 + DIR
    176          * - maximum packet size + interval (in milliseconds)
    177          *   - packed as MPS << 16 + INT
     172         * - USB address + endpoint number (ADDR * 256 + EP)
     173         * - transfer type + direction (TYPE * 256 + DIR)
     174         * - maximum packet size
     175         * - interval (in milliseconds)
    178176         * Answer:
    179177         * - EOK - reservation successful
    … …  
    204202
    205203/** Out transfer processing function prototype. */
    206 typedef int (*usbhc_iface_transfer_out_t)(ddf_fun_t *, usb_target_t,
     204typedef int (*usbhc_iface_transfer_out_t)(ddf_fun_t *, usb_target_t, size_t,
    207205    void *, size_t,
    208206    usbhc_iface_transfer_out_callback_t, void *);
    … …  
    212210
    213211/** In transfer processing function prototype. */
    214 typedef int (*usbhc_iface_transfer_in_t)(ddf_fun_t *, usb_target_t,
     212typedef int (*usbhc_iface_transfer_in_t)(ddf_fun_t *, usb_target_t, size_t,
    215213    void *, size_t,
    216214    usbhc_iface_transfer_in_callback_t, void *);
    … …  
    224222        int (*release_address)(ddf_fun_t *, usb_address_t);
    225223
    226         int (*register_endpoint)(ddf_fun_t *,
    227             usb_address_t, usb_speed_t, usb_endpoint_t,
     224        int (*register_endpoint)(ddf_fun_t *, usb_address_t, usb_endpoint_t,
    228225            usb_transfer_type_t, usb_direction_t, size_t, unsigned int);
    229226        int (*unregister_endpoint)(ddf_fun_t *, usb_address_t, usb_endpoint_t,
    … …  
    237234
    238235        int (*control_write)(ddf_fun_t *, usb_target_t,
     236            size_t,
    239237            void *, size_t, void *, size_t,
    240238            usbhc_iface_transfer_out_callback_t, void *);
    241239
    242240        int (*control_read)(ddf_fun_t *, usb_target_t,
     241            size_t,
    243242            void *, size_t, void *, size_t,
    244243            usbhc_iface_transfer_in_callback_t, void *);

  • uspace/lib/usb/include/usb/devdrv.h

    ra9d67aa r5410c04  
    169169    usb_polling_callback_t, size_t, usb_polling_terminted_callback_t, void *);
    170170
    171 int usb_device_retrieve_descriptors(usb_pipe_t *, usb_device_descriptors_t *);
    172 int usb_device_create_pipes(ddf_dev_t *, usb_device_connection_t *,
    173     usb_endpoint_description_t **, uint8_t *, size_t, int, int,
    174     usb_endpoint_mapping_t **, size_t *);
    175 int usb_device_destroy_pipes(ddf_dev_t *, usb_endpoint_mapping_t *, size_t);
    176 
    177 size_t usb_interface_count_alternates(uint8_t *, size_t, uint8_t);
    178 
    179171#endif
    180172/**

  • uspace/lib/usb/include/usb/host/device_keeper.h

    ra9d67aa r5410c04  
    7373void usb_device_keeper_add_ep(
    7474    usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep);
    75 void usb_device_keeper_del_ep(
    76     usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep);
    7775
    7876void usb_device_keeper_reserve_default_address(

  • uspace/lib/usb/include/usb/pipes.h

    ra9d67aa r5410c04  
    153153int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
    154154    size_t, uint8_t *, size_t, usb_device_connection_t *);
    155 int usb_pipe_register_with_speed(usb_pipe_t *, usb_speed_t,
    156     unsigned int, usb_hc_connection_t *);
    157155int usb_pipe_register(usb_pipe_t *, unsigned int, usb_hc_connection_t *);
    158156int usb_pipe_unregister(usb_pipe_t *, usb_hc_connection_t *);

  • uspace/lib/usb/include/usb/usb.h

    ra9d67aa r5410c04  
    7777        USB_SPEED_FULL,
    7878        /** USB 2.0 high speed (480Mbits/s). */
    79         USB_SPEED_HIGH,
    80         /** Psuedo-speed serving as a boundary. */
    81         USB_SPEED_MAX
     79        USB_SPEED_HIGH
    8280} usb_speed_t;
    8381

  • uspace/lib/usb/src/devdrv.c

    ra9d67aa r5410c04  
    7272}
    7373
     74/** Log out of memory error on given device.
     75 *
     76 * @param dev Device causing the trouble.
     77 */
     78static void usb_log_oom(ddf_dev_t *dev)
     79{
     80        usb_log_error("Out of memory when adding device `%s'.\n",
     81            dev->name);
     82}
     83
    7484/** Count number of pipes the driver expects.
    7585 *
    … …  
    98108 */
    99109static int initialize_other_pipes(usb_endpoint_description_t **endpoints,
    100     usb_device_t *dev, int alternate_setting)
    101 {
    102         usb_endpoint_mapping_t *pipes;
    103         size_t pipes_count;
    104 
    105         int rc = usb_device_create_pipes(dev->ddf_dev, &dev->wire, endpoints,
     110    usb_device_t *dev)
     111{
     112        int rc;
     113
     114        size_t pipe_count = count_other_pipes(endpoints);
     115        if (pipe_count == 0) {
     116                return EOK;
     117        }
     118
     119        dev->pipes = malloc(sizeof(usb_endpoint_mapping_t) * pipe_count);
     120        if (dev->pipes == NULL) {
     121                usb_log_oom(dev->ddf_dev);
     122                return ENOMEM;
     123        }
     124
     125        size_t i;
     126
     127        /* Initialize to NULL first for rollback purposes. */
     128        for (i = 0; i < pipe_count; i++) {
     129                dev->pipes[i].pipe = NULL;
     130        }
     131
     132        for (i = 0; i < pipe_count; i++) {
     133                dev->pipes[i].pipe = malloc(sizeof(usb_pipe_t));
     134                if (dev->pipes[i].pipe == NULL) {
     135                        usb_log_oom(dev->ddf_dev);
     136                        rc = ENOMEM;
     137                        goto rollback;
     138                }
     139
     140                dev->pipes[i].description = endpoints[i];
     141                dev->pipes[i].interface_no = dev->interface_no;
     142                dev->pipes[i].interface_setting = 0;
     143        }
     144
     145        rc = usb_pipe_initialize_from_configuration(dev->pipes, pipe_count,
    106146            dev->descriptors.configuration, dev->descriptors.configuration_size,
    107             dev->interface_no, alternate_setting,
    108             &pipes, &pipes_count);
    109 
     147            &dev->wire);
     148        if (rc != EOK) {
     149                usb_log_error("Failed initializing USB endpoints: %s.\n",
     150                    str_error(rc));
     151                goto rollback;
     152        }
     153
     154        /* Register the endpoints. */
     155        usb_hc_connection_t hc_conn;
     156        rc = usb_hc_connection_initialize_from_device(&hc_conn, dev->ddf_dev);
    110157        if (rc != EOK) {
    111158                usb_log_error(
    112                     "Failed to create endpoint pipes for `%s': %s.\n",
    113                     dev->ddf_dev->name, str_error(rc));
    114                 return rc;
    115         }
    116 
    117         dev->pipes = pipes;
    118         dev->pipes_count = pipes_count;
     159                    "Failed initializing connection to host controller: %s.\n",
     160                    str_error(rc));
     161                goto rollback;
     162        }
     163        rc = usb_hc_connection_open(&hc_conn);
     164        if (rc != EOK) {
     165                usb_log_error("Failed to connect to host controller: %s.\n",
     166                    str_error(rc));
     167                goto rollback;
     168        }
     169        for (i = 0; i < pipe_count; i++) {
     170                if (dev->pipes[i].present) {
     171                        rc = usb_pipe_register(dev->pipes[i].pipe,
     172                            dev->pipes[i].descriptor->poll_interval,
     173                            &hc_conn);
     174                        /* Ignore error when operation not supported by HC. */
     175                        if ((rc != EOK) && (rc != ENOTSUP)) {
     176                                /* FIXME: what shall we do? */
     177                                dev->pipes[i].present = false;
     178                                free(dev->pipes[i].pipe);
     179                                dev->pipes[i].pipe = NULL;
     180                        }
     181                }
     182        }
     183        /* Ignoring errors here. */
     184        usb_hc_connection_close(&hc_conn);
     185
     186        dev->pipes_count = pipe_count;
    119187
    120188        return EOK;
     189
     190rollback:
     191        for (i = 0; i < pipe_count; i++) {
     192                if (dev->pipes[i].pipe != NULL) {
     193                        free(dev->pipes[i].pipe);
     194                }
     195        }
     196        free(dev->pipes);
     197
     198        return rc;
    121199}
    122200
    … …  
    171249        }
    172250
    173         /* Retrieve the descriptors. */
    174         rc = usb_device_retrieve_descriptors(&dev->ctrl_pipe,
    175             &dev->descriptors);
    176         if (rc != EOK) {
    177                 usb_log_error("Failed to retrieve standard device " \
    178                     "descriptors of %s: %s.\n",
     251        /* Get the device descriptor. */
     252        rc = usb_request_get_device_descriptor(&dev->ctrl_pipe,
     253            &dev->descriptors.device);
     254        if (rc != EOK) {
     255                usb_pipe_end_long_transfer(&dev->ctrl_pipe);
     256                usb_log_error("Failed to retrieve device descriptor: %s.\n",
     257                    str_error(rc));
     258                return rc;
     259        }
     260
     261        /* Get the full configuration descriptor. */
     262        rc = usb_request_get_full_configuration_descriptor_alloc(
     263            &dev->ctrl_pipe, 0, (void **) &dev->descriptors.configuration,
     264            &dev->descriptors.configuration_size);
     265        if (rc != EOK) {
     266                usb_pipe_end_long_transfer(&dev->ctrl_pipe);
     267                usb_log_error("Failed retrieving configuration descriptor: %s. %s\n",
    179268                    dev->ddf_dev->name, str_error(rc));
    180269                return rc;
    181270        }
    182271
    183 
    184272        if (driver->endpoints != NULL) {
    185                 rc = initialize_other_pipes(driver->endpoints, dev, 0);
     273                rc = initialize_other_pipes(driver->endpoints, dev);
    186274        }
    187275
    … …  
    205293 * @return Number of alternate interfaces for @p interface_no interface.
    206294 */
    207 size_t usb_interface_count_alternates(uint8_t *config_descr,
    208     size_t config_descr_size, uint8_t interface_no)
     295static size_t count_alternate_interfaces(uint8_t *config_descr,
     296    size_t config_descr_size, int interface_no)
    209297{
    210298        assert(config_descr != NULL);
    211         assert(config_descr_size > 0);
    212 
    213299        usb_dp_parser_t dp_parser = {
    214300                .nesting = usb_dp_standard_descriptor_nesting
    … …  
    259345
    260346        alternates->alternative_count
    261             = usb_interface_count_alternates(dev->descriptors.configuration,
     347            = count_alternate_interfaces(dev->descriptors.configuration,
    262348            dev->descriptors.configuration_size, dev->interface_no);
    263349
    … …  
    373459static int destroy_current_pipes(usb_device_t *dev)
    374460{
    375         int rc = usb_device_destroy_pipes(dev->ddf_dev,
    376             dev->pipes, dev->pipes_count);
    377         if (rc != EOK) {
    378                 return rc;
    379         }
    380 
     461        size_t i;
     462        int rc;
     463
     464        /* TODO: this shall be done under some device mutex. */
     465
     466        /* First check that no session is opened. */
     467        for (i = 0; i < dev->pipes_count; i++) {
     468                if (usb_pipe_is_session_started(dev->pipes[i].pipe)) {
     469                        return EBUSY;
     470                }
     471        }
     472
     473        /* Prepare connection to HC. */
     474        usb_hc_connection_t hc_conn;
     475        rc = usb_hc_connection_initialize_from_device(&hc_conn, dev->ddf_dev);
     476        if (rc != EOK) {
     477                return rc;
     478        }
     479        rc = usb_hc_connection_open(&hc_conn);
     480        if (rc != EOK) {
     481                return rc;
     482        }
     483
     484        /* Destroy the pipes. */
     485        for (i = 0; i < dev->pipes_count; i++) {
     486                usb_pipe_unregister(dev->pipes[i].pipe, &hc_conn);
     487                free(dev->pipes[i].pipe);
     488        }
     489
     490        usb_hc_connection_close(&hc_conn);
     491
     492        free(dev->pipes);
    381493        dev->pipes = NULL;
    382494        dev->pipes_count = 0;
    … …  
    425537
    426538        /* Create new pipes. */
    427         rc = initialize_other_pipes(endpoints, dev, (int) alternate_setting);
     539        rc = initialize_other_pipes(endpoints, dev);
    428540
    429541        return rc;
    430 }
    431 
    432 /** Retrieve basic descriptors from the device.
    433  *
    434  * @param[in] ctrl_pipe Control pipe with opened session.
    435  * @param[out] descriptors Where to store the descriptors.
    436  * @return Error code.
    437  */
    438 int usb_device_retrieve_descriptors(usb_pipe_t *ctrl_pipe,
    439     usb_device_descriptors_t *descriptors)
    440 {
    441         assert(descriptors != NULL);
    442         assert(usb_pipe_is_session_started(ctrl_pipe));
    443 
    444         descriptors->configuration = NULL;
    445 
    446         int rc;
    447 
    448         /* Get the device descriptor. */
    449         rc = usb_request_get_device_descriptor(ctrl_pipe, &descriptors->device);
    450         if (rc != EOK) {
    451                 return rc;
    452         }
    453 
    454         /* Get the full configuration descriptor. */
    455         rc = usb_request_get_full_configuration_descriptor_alloc(
    456             ctrl_pipe, 0, (void **) &descriptors->configuration,
    457             &descriptors->configuration_size);
    458         if (rc != EOK) {
    459                 return rc;
    460         }
    461 
    462         return EOK;
    463 }
    464 
    465 /** Create pipes for a device.
    466  *
    467  * This is more or less a wrapper that does following actions:
    468  * - allocate and initialize pipes
    469  * - map endpoints to the pipes based on the descriptions
    470  * - registers endpoints with the host controller
    471  *
    472  * @param[in] dev Generic DDF device backing the USB one.
    473  * @param[in] wire Initialized backing connection to the host controller.
    474  * @param[in] endpoints Endpoints description, NULL terminated.
    475  * @param[in] config_descr Configuration descriptor of active configuration.
    476  * @param[in] config_descr_size Size of @p config_descr in bytes.
    477  * @param[in] interface_no Interface to map from.
    478  * @param[in] interface_setting Interface setting (default is usually 0).
    479  * @param[out] pipes_ptr Where to store array of created pipes
    480  *      (not NULL terminated).
    481  * @param[out] pipes_count_ptr Where to store number of pipes
    482  *      (set to if you wish to ignore the count).
    483  * @return Error code.
    484  */
    485 int usb_device_create_pipes(ddf_dev_t *dev, usb_device_connection_t *wire,
    486     usb_endpoint_description_t **endpoints,
    487     uint8_t *config_descr, size_t config_descr_size,
    488     int interface_no, int interface_setting,
    489     usb_endpoint_mapping_t **pipes_ptr, size_t *pipes_count_ptr)
    490 {
    491         assert(dev != NULL);
    492         assert(wire != NULL);
    493         assert(endpoints != NULL);
    494         assert(config_descr != NULL);
    495         assert(config_descr_size > 0);
    496         assert(pipes_ptr != NULL);
    497 
    498         size_t i;
    499         int rc;
    500 
    501         size_t pipe_count = count_other_pipes(endpoints);
    502         if (pipe_count == 0) {
    503                 *pipes_ptr = NULL;
    504                 return EOK;
    505         }
    506 
    507         usb_endpoint_mapping_t *pipes
    508             = malloc(sizeof(usb_endpoint_mapping_t) * pipe_count);
    509         if (pipes == NULL) {
    510                 return ENOMEM;
    511         }
    512 
    513         /* Initialize to NULL to allow smooth rollback. */
    514         for (i = 0; i < pipe_count; i++) {
    515                 pipes[i].pipe = NULL;
    516         }
    517 
    518         /* Now allocate and fully initialize. */
    519         for (i = 0; i < pipe_count; i++) {
    520                 pipes[i].pipe = malloc(sizeof(usb_pipe_t));
    521                 if (pipes[i].pipe == NULL) {
    522                         rc = ENOMEM;
    523                         goto rollback_free_only;
    524                 }
    525                 pipes[i].description = endpoints[i];
    526                 pipes[i].interface_no = interface_no;
    527                 pipes[i].interface_setting = interface_setting;
    528         }
    529 
    530         /* Find the mapping from configuration descriptor. */
    531         rc = usb_pipe_initialize_from_configuration(pipes, pipe_count,
    532             config_descr, config_descr_size, wire);
    533         if (rc != EOK) {
    534                 goto rollback_free_only;
    535         }
    536 
    537         /* Register the endpoints with HC. */
    538         usb_hc_connection_t hc_conn;
    539         rc = usb_hc_connection_initialize_from_device(&hc_conn, dev);
    540         if (rc != EOK) {
    541                 goto rollback_free_only;
    542         }
    543 
    544         rc = usb_hc_connection_open(&hc_conn);
    545         if (rc != EOK) {
    546                 goto rollback_free_only;
    547         }
    548 
    549         for (i = 0; i < pipe_count; i++) {
    550                 if (pipes[i].present) {
    551                         rc = usb_pipe_register(pipes[i].pipe,
    552                             pipes[i].descriptor->poll_interval, &hc_conn);
    553                         if (rc != EOK) {
    554                                 goto rollback_unregister_endpoints;
    555                         }
    556                 }
    557         }
    558 
    559         usb_hc_connection_close(&hc_conn);
    560 
    561         *pipes_ptr = pipes;
    562         if (pipes_count_ptr != NULL) {
    563                 *pipes_count_ptr = pipe_count;
    564         }
    565 
    566         return EOK;
    567 
    568         /*
    569          * Jump here if something went wrong after endpoints have
    570          * been registered.
    571          * This is also the target when the registration of
    572          * endpoints fails.
    573          */
    574 rollback_unregister_endpoints:
    575         for (i = 0; i < pipe_count; i++) {
    576                 if (pipes[i].present) {
    577                         usb_pipe_unregister(pipes[i].pipe, &hc_conn);
    578                 }
    579         }
    580 
    581         usb_hc_connection_close(&hc_conn);
    582 
    583         /*
    584          * Jump here if something went wrong before some actual communication
    585          * with HC. Then the only thing that needs to be done is to free
    586          * allocated memory.
    587          */
    588 rollback_free_only:
    589         for (i = 0; i < pipe_count; i++) {
    590                 if (pipes[i].pipe != NULL) {
    591                         free(pipes[i].pipe);
    592                 }
    593         }
    594         free(pipes);
    595 
    596         return rc;
    597 }
    598 
    599 /** Destroy pipes previously created by usb_device_create_pipes.
    600  *
    601  * @param[in] dev Generic DDF device backing the USB one.
    602  * @param[in] pipes Endpoint mapping to be destroyed.
    603  * @param[in] pipes_count Number of endpoints.
    604  */
    605 int usb_device_destroy_pipes(ddf_dev_t *dev,
    606     usb_endpoint_mapping_t *pipes, size_t pipes_count)
    607 {
    608         assert(dev != NULL);
    609         assert(((pipes != NULL) && (pipes_count > 0))
    610             || ((pipes == NULL) && (pipes_count == 0)));
    611 
    612         if (pipes_count == 0) {
    613                 return EOK;
    614         }
    615 
    616         int rc;
    617 
    618         /* Prepare connection to HC to allow endpoint unregistering. */
    619         usb_hc_connection_t hc_conn;
    620         rc = usb_hc_connection_initialize_from_device(&hc_conn, dev);
    621         if (rc != EOK) {
    622                 return rc;
    623         }
    624         rc = usb_hc_connection_open(&hc_conn);
    625         if (rc != EOK) {
    626                 return rc;
    627         }
    628 
    629         /* Destroy the pipes. */
    630         size_t i;
    631         for (i = 0; i < pipes_count; i++) {
    632                 usb_pipe_unregister(pipes[i].pipe, &hc_conn);
    633                 free(pipes[i].pipe);
    634         }
    635 
    636         usb_hc_connection_close(&hc_conn);
    637 
    638         free(pipes);
    639 
    640         return EOK;
    641542}
    642543

  • uspace/lib/usb/src/host/device_keeper.c

    ra9d67aa r5410c04  
    5656                instance->devices[i].control_used = 0;
    5757                instance->devices[i].handle = 0;
    58                 instance->devices[i].speed = USB_SPEED_MAX;
    5958                list_initialize(&instance->devices[i].endpoints);
    6059        }
    61         // TODO: is this hack enough?
    62         // (it is needed to allow smooth registration at default address)
    63         instance->devices[0].occupied = true;
    6460}
    6561/*----------------------------------------------------------------------------*/
    … …  
    7167        assert(instance->devices[address].occupied);
    7268        list_append(&ep->same_device_eps, &instance->devices[address].endpoints);
    73         fibril_mutex_unlock(&instance->guard);
    74 }
    75 /*----------------------------------------------------------------------------*/
    76 void usb_device_keeper_del_ep(
    77     usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep)
    78 {
    79         assert(instance);
    80         fibril_mutex_lock(&instance->guard);
    81         assert(instance->devices[address].occupied);
    82         list_remove(&ep->same_device_eps);
    83         list_initialize(&ep->same_device_eps);
    8469        fibril_mutex_unlock(&instance->guard);
    8570}

  • uspace/lib/usb/src/hub.c

    ra9d67aa r5410c04  
    4040#include <errno.h>
    4141#include <assert.h>
    42 #include <usb/debug.h>
    4342
    4443/** Check that HC connection is alright.
    … …  
    5655
    5756/** Tell host controller to reserve default address.
    58  * @deprecated
    5957 *
    6058 * @param connection Opened connection to host controller.
    … …  
    6765        CHECK_CONNECTION(connection);
    6866
    69         usb_log_warning("usb_hc_reserve_default_address() considered obsolete");
    70 
    7167        return async_req_2_0(connection->hc_phone,
    7268            DEV_IFACE_ID(USBHC_DEV_IFACE),
    … …  
    7571
    7672/** Tell host controller to release default address.
    77  * @deprecated
    7873 *
    7974 * @param connection Opened connection to host controller.
    … …  
    8378{
    8479        CHECK_CONNECTION(connection);
    85 
    86         usb_log_warning("usb_hc_release_default_address() considered obsolete");
    8780
    8881        return async_req_1_0(connection->hc_phone,
    … …  
    242235        }
    243236
    244         /*
    245          * We will not register control pipe on default address.
    246          * The registration might fail. That means that someone else already
    247          * registered that endpoint. We will simply wait and try again.
    248          * (Someone else already wants to add a new device.)
     237
     238        /*
     239         * Reserve the default address.
     240         */
     241        rc = usb_hc_reserve_default_address(&hc_conn, dev_speed);
     242        if (rc != EOK) {
     243                rc = EBUSY;
     244                goto leave_release_free_address;
     245        }
     246
     247        /*
     248         * Enable the port (i.e. allow signaling through this port).
     249         */
     250        rc = enable_port(port_no, arg);
     251        if (rc != EOK) {
     252                goto leave_release_default_address;
     253        }
     254
     255        /*
     256         * Change the address from default to the free one.
     257         * We need to create a new control pipe for that.
    249258         */
    250259        usb_device_connection_t dev_conn;
    … …  
    253262        if (rc != EOK) {
    254263                rc = ENOTCONN;
    255                 goto leave_release_free_address;
     264                goto leave_release_default_address;
    256265        }
    257266
    … …  
    261270        if (rc != EOK) {
    262271                rc = ENOTCONN;
    263                 goto leave_release_free_address;
    264         }
    265 
    266         do {
    267                 rc = usb_pipe_register_with_speed(&ctrl_pipe, dev_speed, 0,
    268                     &hc_conn);
    269                 if (rc != EOK) {
    270                         /* Do not overheat the CPU ;-). */
    271                         async_usleep(10);
    272                 }
    273         } while (rc != EOK);
    274 
    275         /*
    276          * Endpoint is registered. We can enable the port and change
    277          * device address.
    278          */
    279         rc = enable_port(port_no, arg);
    280         if (rc != EOK) {
    281                 goto leave_release_default_address;
    282         }
    283 
     272                goto leave_release_default_address;
     273        }
     274
     275        /* Before sending any traffic, we need to register this
     276         * endpoint.
     277         */
     278        rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
     279        if (rc != EOK) {
     280                rc = EREFUSED;
     281                goto leave_release_default_address;
     282        }
    284283        rc = usb_pipe_probe_default_control(&ctrl_pipe);
    285284        if (rc != EOK) {
     285                rc = ENOTCONN;
     286                goto leave_release_default_address;
     287        }
     288
     289        rc = usb_request_set_address(&ctrl_pipe, dev_addr);
     290        if (rc != EOK) {
    286291                rc = ESTALL;
    287                 goto leave_release_default_address;
    288         }
    289 
    290         rc = usb_request_set_address(&ctrl_pipe, dev_addr);
    291         if (rc != EOK) {
    292                 rc = ESTALL;
    293                 goto leave_release_default_address;
    294         }
    295 
    296         /*
    297          * Address changed. We can release the original endpoint, thus
    298          * allowing other to access the default address.
     292                goto leave_stop_session;
     293        }
     294
     295        /*
     296         * Register the control endpoint for the new device.
     297         */
     298        rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
     299        if (rc != EOK) {
     300                rc = EREFUSED;
     301                goto leave_unregister_endpoint;
     302        }
     303
     304        /*
     305         * Release the original endpoint.
    299306         */
    300307        unregister_control_endpoint_on_default_address(&hc_conn);
    301308
    302309        /*
    303          * Time to register the new endpoint.
    304          */
    305         rc = usb_pipe_register(&ctrl_pipe, 0, &hc_conn);
    306         if (rc != EOK) {
    307                 goto leave_release_free_address;
    308         }
     310         * Once the address is changed, we can return the default address.
     311         */
     312        usb_hc_release_default_address(&hc_conn);
     313
    309314
    310315        /*
    … …  
    321326        }
    322327
     328
     329
    323330        /*
    324331         * And now inform the host controller about the handle.
    … …  
    352359         * Completely ignoring errors here.
    353360         */
     361
     362leave_stop_session:
     363        usb_pipe_end_session(&ctrl_pipe);
     364
     365leave_unregister_endpoint:
     366        usb_pipe_unregister(&ctrl_pipe, &hc_conn);
     367
    354368leave_release_default_address:
    355         usb_pipe_unregister(&ctrl_pipe, &hc_conn);
     369        usb_hc_release_default_address(&hc_conn);
    356370
    357371leave_release_free_address:

  • uspace/lib/usb/src/pipesinit.c

    ra9d67aa r5410c04  
    459459    usb_hc_connection_t *hc_connection)
    460460{
    461         return usb_pipe_register_with_speed(pipe, USB_SPEED_MAX + 1,
    462             interval, hc_connection);
    463 }
    464 
    465 /** Register endpoint with a speed at the host controller.
    466  *
    467  * You will rarely need to use this function because it is needed only
    468  * if the registered endpoint is of address 0 and there is no other way
    469  * to tell speed of the device at address 0.
    470  *
    471  * @param pipe Pipe to be registered.
    472  * @param speed Speed of the device
    473  *      (invalid speed means use previously specified one).
    474  * @param interval Polling interval.
    475  * @param hc_connection Connection to the host controller (must be opened).
    476  * @return Error code.
    477  */
    478 int usb_pipe_register_with_speed(usb_pipe_t *pipe, usb_speed_t speed,
    479     unsigned int interval,
    480     usb_hc_connection_t *hc_connection)
    481 {
    482461        assert(pipe);
    483462        assert(hc_connection);
    … …  
    487466        }
    488467
    489 #define _PACK2(high, low) (((high) << 16) + (low))
    490 #define _PACK3(high, middle, low) (((((high) << 8) + (middle)) << 8) + (low))
    491 
    492         return async_req_4_0(hc_connection->hc_phone,
     468#define _PACK(high, low) ((high) * 256 + (low))
     469
     470        return async_req_5_0(hc_connection->hc_phone,
    493471            DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_REGISTER_ENDPOINT,
    494             _PACK2(pipe->wire->address, pipe->endpoint_no),
    495             _PACK3(speed, pipe->transfer_type, pipe->direction),
    496             _PACK2(pipe->max_packet_size, interval));
    497 
    498 #undef _PACK2
    499 #undef _PACK3
     472            _PACK(pipe->wire->address, pipe->endpoint_no),
     473            _PACK(pipe->transfer_type, pipe->direction),
     474            pipe->max_packet_size, interval);
     475
     476#undef _PACK
    500477}
    501478

  • uspace/lib/usb/src/pipesio.c

    ra9d67aa r5410c04  
    8585         * Make call identifying target USB device and type of transfer.
    8686         */
    87         aid_t opening_request = async_send_3(pipe->hc_phone,
     87        aid_t opening_request = async_send_4(pipe->hc_phone,
    8888            DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method,
    8989            pipe->wire->address, pipe->endpoint_no,
     90            pipe->max_packet_size,
    9091            NULL);
    9192        if (opening_request == 0) {
    … …  
    231232         * Make call identifying target USB device and type of transfer.
    232233         */
    233         aid_t opening_request = async_send_3(pipe->hc_phone,
     234        aid_t opening_request = async_send_4(pipe->hc_phone,
    234235            DEV_IFACE_ID(USBHC_DEV_IFACE), ipc_method,
    235236            pipe->wire->address, pipe->endpoint_no,
     237            pipe->max_packet_size,
    236238            NULL);
    237239        if (opening_request == 0) {
    … …  
    329331         * Make call identifying target USB device and control transfer type.
    330332         */
    331         aid_t opening_request = async_send_3(pipe->hc_phone,
     333        aid_t opening_request = async_send_4(pipe->hc_phone,
    332334            DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_READ,
    333335            pipe->wire->address, pipe->endpoint_no,
     336            pipe->max_packet_size,
    334337            NULL);
    335338        if (opening_request == 0) {
    … …  
    470473         * Make call identifying target USB device and control transfer type.
    471474         */
    472         aid_t opening_request = async_send_4(pipe->hc_phone,
     475        aid_t opening_request = async_send_5(pipe->hc_phone,
    473476            DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_CONTROL_WRITE,
    474477            pipe->wire->address, pipe->endpoint_no,
    475478            data_buffer_size,
     479            pipe->max_packet_size,
    476480            NULL);
    477481        if (opening_request == 0) {
Note: See TracChangeset for help on using the changeset viewer.