Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbdev/src/pipes.c

    r9d58539 r58563585  
    3535#include <usb/dev/pipes.h>
    3636#include <usb/dev/request.h>
     37#include <usb/usb.h>
     38#include <usb_iface.h>
     39
     40#include <assert.h>
     41#include <async.h>
    3742#include <errno.h>
    38 #include <assert.h>
    39 
    40 /** Prepare pipe for a long transfer.
    41  *
    42  * Long transfer is transfer consisting of several requests to the HC.
    43  * Calling this function is optional and it has positive effect of
    44  * improved performance because IPC session is initiated only once.
    45  *
    46  * @param pipe Pipe over which the transfer will happen.
    47  * @return Error code.
    48  */
    49 int usb_pipe_start_long_transfer(usb_pipe_t *pipe)
    50 {
    51         assert(pipe);
    52         assert(pipe->wire);
    53         assert(pipe->wire->hc_connection);
    54         return usb_hc_connection_open(pipe->wire->hc_connection);
    55 }
    56 /*----------------------------------------------------------------------------*/
    57 /** Terminate a long transfer on a pipe.
    58  * @param pipe Pipe where to end the long transfer.
    59  * @return Error code.
    60  * @see usb_pipe_start_long_transfer
    61  */
    62 int usb_pipe_end_long_transfer(usb_pipe_t *pipe)
    63 {
    64         assert(pipe);
    65         assert(pipe->wire);
    66         assert(pipe->wire->hc_connection);
    67         return usb_hc_connection_close(pipe->wire->hc_connection);
    68 }
    69 /*----------------------------------------------------------------------------*/
     43#include <mem.h>
     44
    7045/** Try to clear endpoint halt of default control pipe.
    7146 *
    … …  
    8560        pipe->auto_reset_halt = true;
    8661}
    87 /*----------------------------------------------------------------------------*/
     62
    8863/** Request a control read transfer on an endpoint pipe.
    8964 *
    … …  
    12196        memcpy(&setup_packet, setup_buffer, 8);
    12297
     98        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    12399        size_t act_size = 0;
    124         const int rc = usb_device_control_read(pipe->wire,
    125             pipe->endpoint_no, setup_packet, buffer, buffer_size, &act_size);
     100        const int rc = usb_read(exch, pipe->endpoint_no, setup_packet, buffer,
     101            buffer_size, &act_size);
     102        async_exchange_end(exch);
    126103
    127104        if (rc == ESTALL) {
    … …  
    135112        return rc;
    136113}
    137 /*----------------------------------------------------------------------------*/
     114
    138115/** Request a control write transfer on an endpoint pipe.
    139116 *
    … …  
    173150        memcpy(&setup_packet, setup_buffer, 8);
    174151
    175         const int rc = usb_device_control_write(pipe->wire,
     152        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
     153        const int rc = usb_write(exch,
    176154            pipe->endpoint_no, setup_packet, buffer, buffer_size);
     155        async_exchange_end(exch);
    177156
    178157        if (rc == ESTALL) {
    … …  
    182161        return rc;
    183162}
    184 /*----------------------------------------------------------------------------*/
     163
    185164/** Request a read (in) transfer on an endpoint pipe.
    186165 *
    … …  
    217196            return ENOTSUP;
    218197
     198        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    219199        size_t act_size = 0;
    220         const int rc = usb_device_read(pipe->wire,
    221             pipe->endpoint_no, buffer, size, &act_size);
     200        const int rc =
     201            usb_read(exch, pipe->endpoint_no, 0, buffer, size, &act_size);
     202        async_exchange_end(exch);
    222203
    223204        if (rc == EOK && size_transfered != NULL) {
    … …  
    227208        return rc;
    228209}
    229 /*----------------------------------------------------------------------------*/
     210
    230211/** Request a write (out) transfer on an endpoint pipe.
    231212 *
    … …  
    256237            return ENOTSUP;
    257238
    258         return usb_device_write(pipe->wire,
    259             pipe->endpoint_no, buffer, size);
    260 }
    261 /*----------------------------------------------------------------------------*/
     239        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
     240        const int rc = usb_write(exch, pipe->endpoint_no, 0, buffer, size);
     241        async_exchange_end(exch);
     242        return rc;
     243}
     244
    262245/** Initialize USB endpoint pipe.
    263246 *
    264247 * @param pipe Endpoint pipe to be initialized.
    265  * @param connection Connection to the USB device backing this pipe (the wire).
    266248 * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15).
    267249 * @param transfer_type Transfer type (e.g. interrupt or bulk).
    … …  
    270252 * @return Error code.
    271253 */
    272 int usb_pipe_initialize(usb_pipe_t *pipe,
    273     usb_device_connection_t *connection, usb_endpoint_t endpoint_no,
     254int usb_pipe_initialize(usb_pipe_t *pipe, usb_endpoint_t endpoint_no,
    274255    usb_transfer_type_t transfer_type, size_t max_packet_size,
    275     usb_direction_t direction)
    276 {
    277         assert(pipe);
    278         assert(connection);
    279 
    280         pipe->wire = connection;
     256    usb_direction_t direction, unsigned packets, usb_dev_session_t *bus_session)
     257{
     258        assert(pipe);
     259
    281260        pipe->endpoint_no = endpoint_no;
    282261        pipe->transfer_type = transfer_type;
     262        pipe->packets = packets;
    283263        pipe->max_packet_size = max_packet_size;
    284264        pipe->direction = direction;
    285265        pipe->auto_reset_halt = false;
     266        pipe->bus_session = bus_session;
    286267
    287268        return EOK;
    288269}
    289 /*----------------------------------------------------------------------------*/
     270
    290271/** Initialize USB endpoint pipe as the default zero control pipe.
    291272 *
    292273 * @param pipe Endpoint pipe to be initialized.
    293  * @param connection Connection to the USB device backing this pipe (the wire).
    294274 * @return Error code.
    295275 */
    296276int usb_pipe_initialize_default_control(usb_pipe_t *pipe,
    297     usb_device_connection_t *connection)
    298 {
    299         assert(pipe);
    300         assert(connection);
    301 
    302         int rc = usb_pipe_initialize(pipe, connection, 0, USB_TRANSFER_CONTROL,
    303             CTRL_PIPE_MIN_PACKET_SIZE, USB_DIRECTION_BOTH);
     277    usb_dev_session_t *bus_session)
     278{
     279        assert(pipe);
     280
     281        const int rc = usb_pipe_initialize(pipe, 0, USB_TRANSFER_CONTROL,
     282            CTRL_PIPE_MIN_PACKET_SIZE, USB_DIRECTION_BOTH, 1, bus_session);
    304283
    305284        pipe->auto_reset_halt = true;
    … …  
    307286        return rc;
    308287}
    309 /*----------------------------------------------------------------------------*/
     288
    310289/** Register endpoint with the host controller.
    311290 *
    … …  
    317296{
    318297        assert(pipe);
    319         assert(pipe->wire);
    320 
    321         return usb_device_register_endpoint(pipe->wire,
    322            pipe->endpoint_no, pipe->transfer_type,
    323            pipe->direction, pipe->max_packet_size, interval);
    324 }
    325 /*----------------------------------------------------------------------------*/
     298        assert(pipe->bus_session);
     299        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
     300        if (!exch)
     301                return ENOMEM;
     302        const int ret = usb_register_endpoint(exch, pipe->endpoint_no,
     303            pipe->transfer_type, pipe->direction, pipe->max_packet_size,
     304            pipe->packets, interval);
     305        async_exchange_end(exch);
     306        return ret;
     307}
     308
    326309/** Revert endpoint registration with the host controller.
    327310 *
    … …  
    332315{
    333316        assert(pipe);
    334         assert(pipe->wire);
    335 
    336         return usb_device_unregister_endpoint(pipe->wire,
    337             pipe->endpoint_no, pipe->direction);
     317        assert(pipe->bus_session);
     318        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
     319        if (!exch)
     320                return ENOMEM;
     321        const int ret = usb_unregister_endpoint(exch, pipe->endpoint_no,
     322            pipe->direction);
     323        async_exchange_end(exch);
     324        return ret;
    338325}
    339326
Note: See TracChangeset for help on using the changeset viewer.