Changeset 6bec59b in mainline


Ignore:
Timestamp:
2011-04-08T13:58:45Z (14 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f98b8269
Parents:
6acc80f3
Message:

Port endpoint framework usage from UHCI

Location:
uspace/drv/ohci
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/batch.c

    r6acc80f3 r6bec59b  
    4545
    4646#define DEFAULT_ERROR_COUNT 3
    47 usb_transfer_batch_t * batch_get(
    48     ddf_fun_t *fun,
    49                 usb_target_t target,
    50     usb_transfer_type_t transfer_type,
    51                 size_t max_packet_size,
    52     usb_speed_t speed,
    53                 char *buffer,
    54                 size_t buffer_size,
    55                 char *setup_buffer,
    56                 size_t setup_size,
     47usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
     48    char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
    5749    usbhc_iface_transfer_in_callback_t func_in,
    58     usbhc_iface_transfer_out_callback_t func_out,
    59                 void *arg,
    60                 usb_device_keeper_t *manager
    61                 )
     50    usbhc_iface_transfer_out_callback_t func_out, void *arg)
    6251{
    6352#define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
    … …  
    7362        CHECK_NULL_DISPOSE_RETURN(instance,
    7463            "Failed to allocate batch instance.\n");
    75         usb_transfer_batch_init(instance, target, transfer_type, speed,
    76             max_packet_size, buffer, NULL, buffer_size, NULL, setup_size,
    77             func_in, func_out, arg, fun, NULL, NULL);
     64        usb_target_t target =
     65            { .address = ep->address, .endpoint = ep->endpoint };
     66        usb_transfer_batch_init(instance, target, ep->transfer_type, ep->speed,
     67            ep->max_packet_size, buffer, NULL, buffer_size, NULL, setup_size,
     68            func_in, func_out, arg, fun, ep, NULL);
    7869
    7970        if (buffer_size > 0) {

  • uspace/drv/ohci/batch.h

    r6acc80f3 r6bec59b  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28 /** @addtogroup drvusbohci
     28/** @addtogroup drvusbuhcihc
    2929 * @{
    3030 */
    3131/** @file
    32  * @brief OHCI driver USB transaction structure
     32 * @brief UHCI driver USB transaction structure
    3333 */
    34 #ifndef DRV_OHCI_BATCH_H
    35 #define DRV_OHCI_BATCH_H
    36 
     34#ifndef DRV_UHCI_BATCH_H
     35#define DRV_UHCI_BATCH_H
    3736
    3837#include <usbhc_iface.h>
    3938#include <usb/usb.h>
    4039#include <usb/host/device_keeper.h>
     40#include <usb/host/endpoint.h>
    4141#include <usb/host/batch.h>
    4242
     43
    4344usb_transfer_batch_t * batch_get(
    44     ddf_fun_t *fun,
    45                 usb_target_t target,
    46     usb_transfer_type_t transfer_type,
    47                 size_t max_packet_size,
    48     usb_speed_t speed,
    49                 char *buffer,
    50                 size_t size,
    51                 char *setup_buffer,
    52                 size_t setup_size,
     45    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
     46    char *setup_buffer, size_t setup_size,
    5347    usbhc_iface_transfer_in_callback_t func_in,
    5448    usbhc_iface_transfer_out_callback_t func_out,
    55                 void *arg,
    56                 usb_device_keeper_t *manager
    57                 );
     49    void *arg);
    5850
    5951void batch_dispose(usb_transfer_batch_t *instance);
     52
     53bool batch_is_complete(usb_transfer_batch_t *instance);
    6054
    6155void batch_control_write(usb_transfer_batch_t *instance);
    … …  
    7064
    7165void batch_bulk_out(usb_transfer_batch_t *instance);
     66
    7267#endif
    7368/**

  • uspace/drv/ohci/hc.c

    r6acc80f3 r6bec59b  
    5959            &instance->manager, hub_address, hub_fun->handle);
    6060
     61        endpoint_t *ep = malloc(sizeof(endpoint_t));
     62        assert(ep);
     63        int ret = endpoint_init(ep, hub_address, 0, USB_DIRECTION_BOTH,
     64            USB_TRANSFER_CONTROL, USB_SPEED_FULL, 64);
     65        assert(ret == EOK);
     66        ret = usb_endpoint_manager_register_ep(&instance->ep_manager, ep, 0);
     67        assert(ret == EOK);
     68
    6169        char *match_str = NULL;
    62         int ret = asprintf(&match_str, "usb&class=hub");
    63         ret = (match_str == NULL) ? ret : EOK;
     70        ret = asprintf(&match_str, "usb&class=hub");
     71//      ret = (match_str == NULL) ? ret : EOK;
    6472        if (ret < 0) {
    65                 usb_log_error("Failed to create root hub match-id string.\n");
     73                usb_log_error(
     74                    "Failed(%d) to create root hub match-id string.\n", ret);
    6675                return ret;
    6776        }

  • uspace/drv/ohci/iface.c

    r6acc80f3 r6bec59b  
    11/*
    2  * Copyright (c) 2011 Vojtech Horky
     2 * Copyright (c) 2011 Vojtech Horky, Jan Vesely
    33 * All rights reserved.
    44 *
    … …  
    3030 */
    3131/** @file
    32  * USB-HC interface implementation.
     32 * @brief OHCI driver hc interface implementation
    3333 */
    3434#include <ddf/driver.h>
    … …  
    3636
    3737#include <usb/debug.h>
     38#include <usb/host/endpoint.h>
    3839
    3940#include "iface.h"
    4041#include "hc.h"
    4142
    42 #define UNSUPPORTED(methodname) \
    43         usb_log_warning("Unsupported interface method `%s()' in %s:%d.\n", \
    44             methodname, __FILE__, __LINE__)
    45 
    46 /** Reserve default address.
    47  *
    48  * This function may block the caller.
    49  *
    50  * @param[in] fun Device function the action was invoked on.
    51  * @param[in] speed Speed of the device for which the default address is
    52  *      reserved.
     43static inline int setup_batch(
     44    ddf_fun_t *fun, usb_target_t target, usb_direction_t direction,
     45    void *data, size_t size, void * setup_data, size_t setup_size,
     46    usbhc_iface_transfer_in_callback_t in,
     47    usbhc_iface_transfer_out_callback_t out, void *arg, const char* name,
     48    hc_t **hc, usb_transfer_batch_t **batch)
     49{
     50        assert(hc);
     51        assert(batch);
     52        assert(fun);
     53        *hc = fun_to_hc(fun);
     54        assert(*hc);
     55
     56        size_t res_bw;
     57        endpoint_t *ep = usb_endpoint_manager_get_ep(&(*hc)->ep_manager,
     58            target.address, target.endpoint, direction, &res_bw);
     59        if (ep == NULL) {
     60                usb_log_error("Endpoint(%d:%d) not registered for %s.\n",
     61                    target.address, target.endpoint, name);
     62                return ENOENT;
     63        }
     64
     65        const size_t bw = bandwidth_count_usb11(
     66            ep->speed, ep->transfer_type, size, ep->max_packet_size);
     67        if (res_bw < bw) {
     68                usb_log_error("Endpoint(%d:%d) %s needs %zu bw "
     69                    "but only %zu is reserved.\n",
     70                    name, target.address, target.endpoint, bw, res_bw);
     71                return ENOSPC;
     72        }
     73        usb_log_debug("%s %d:%d %zu(%zu).\n",
     74            name, target.address, target.endpoint, size, ep->max_packet_size);
     75
     76        assert(ep->speed ==
     77            usb_device_keeper_get_speed(&(*hc)->manager, target.address));
     78//      assert(ep->max_packet_size == max_packet_size);
     79//      assert(ep->transfer_type == USB_TRANSFER_CONTROL);
     80
     81        *batch =
     82            batch_get(fun, ep, data, size, setup_data, setup_size,
     83                in, out, arg);
     84        if (!batch)
     85                return ENOMEM;
     86        return EOK;
     87}
     88
     89
     90/** Reserve default address interface function
     91 *
     92 * @param[in] fun DDF function that was called.
     93 * @param[in] speed Speed to associate with the new default address.
    5394 * @return Error code.
    5495 */
    … …  
    61102        usb_device_keeper_reserve_default_address(&hc->manager, speed);
    62103        return EOK;
    63 }
    64 /*----------------------------------------------------------------------------*/
    65 /** Release default address.
    66  *
    67  * @param[in] fun Device function the action was invoked on.
     104#if 0
     105        endpoint_t *ep = malloc(sizeof(endpoint_t));
     106        if (ep == NULL)
     107                return ENOMEM;
     108        const size_t max_packet_size = speed == USB_SPEED_LOW ? 8 : 64;
     109        endpoint_init(ep, USB_TRANSFER_CONTROL, speed, max_packet_size);
     110        int ret;
     111try_retgister:
     112        ret = usb_endpoint_manager_register_ep(&hc->ep_manager,
     113            USB_ADDRESS_DEFAULT, 0, USB_DIRECTION_BOTH, ep, endpoint_destroy, 0);
     114        if (ret == EEXISTS) {
     115                async_usleep(1000);
     116                goto try_retgister;
     117        }
     118        if (ret != EOK) {
     119                endpoint_destroy(ep);
     120        }
     121        return ret;
     122#endif
     123}
     124/*----------------------------------------------------------------------------*/
     125/** Release default address interface function
     126 *
     127 * @param[in] fun DDF function that was called.
    68128 * @return Error code.
    69129 */
    … …  
    74134        assert(hc);
    75135        usb_log_debug("Default address release.\n");
     136//      return usb_endpoint_manager_unregister_ep(&hc->ep_manager,
     137//          USB_ADDRESS_DEFAULT, 0, USB_DIRECTION_BOTH);
    76138        usb_device_keeper_release_default_address(&hc->manager);
    77139        return EOK;
    78140}
    79141/*----------------------------------------------------------------------------*/
    80 /** Found free USB address.
    81  *
    82  * @param[in] fun Device function the action was invoked on.
    83  * @param[in] speed Speed of the device that will get this address.
    84  * @param[out] address Non-null pointer where to store the free address.
     142/** Request address interface function
     143 *
     144 * @param[in] fun DDF function that was called.
     145 * @param[in] speed Speed to associate with the new default address.
     146 * @param[out] address Place to write a new address.
    85147 * @return Error code.
    86148 */
    … …  
    101163}
    102164/*----------------------------------------------------------------------------*/
    103 /** Bind USB address with device devman handle.
    104  *
    105  * @param[in] fun Device function the action was invoked on.
    106  * @param[in] address USB address of the device.
    107  * @param[in] handle Devman handle of the device.
     165/** Bind address interface function
     166 *
     167 * @param[in] fun DDF function that was called.
     168 * @param[in] address Address of the device
     169 * @param[in] handle Devman handle of the device driver.
    108170 * @return Error code.
    109171 */
    110172static int bind_address(
    111     ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
     173  ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
    112174{
    113175        assert(fun);
    … …  
    119181}
    120182/*----------------------------------------------------------------------------*/
    121 /** Release previously requested address.
    122  *
    123  * @param[in] fun Device function the action was invoked on.
     183/** Release address interface function
     184 *
     185 * @param[in] fun DDF function that was called.
    124186 * @param[in] address USB address to be released.
    125187 * @return Error code.
    … …  
    135197}
    136198/*----------------------------------------------------------------------------*/
    137 /** Register endpoint for bandwidth reservation.
    138  *
    139  * @param[in] fun Device function the action was invoked on.
    140  * @param[in] address USB address of the device.
    141  * @param[in] endpoint Endpoint number.
    142  * @param[in] transfer_type USB transfer type.
    143  * @param[in] direction Endpoint data direction.
    144  * @param[in] max_packet_size Max packet size of the endpoint.
    145  * @param[in] interval Polling interval.
    146  * @return Error code.
    147  */
    148199static int register_endpoint(
    149200    ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
    … …  
    151202    size_t max_packet_size, unsigned int interval)
    152203{
    153         assert(fun);
    154         hc_t *hc = fun_to_hc(fun);
    155         assert(hc);
    156         if (address == hc->rh.address)
    157                 return EOK;
     204        hc_t *hc = fun_to_hc(fun);
     205        assert(hc);
    158206        const usb_speed_t speed =
    159                 usb_device_keeper_get_speed(&hc->manager, address);
    160         const size_t size = max_packet_size;
     207            usb_device_keeper_get_speed(&hc->manager, address);
     208        const size_t size =
     209            (transfer_type == USB_TRANSFER_INTERRUPT
     210            || transfer_type == USB_TRANSFER_ISOCHRONOUS) ?
     211            max_packet_size : 0;
     212        int ret;
     213
     214        endpoint_t *ep = malloc(sizeof(endpoint_t));
     215        if (ep == NULL)
     216                return ENOMEM;
     217        ret = endpoint_init(ep, address, endpoint, direction,
     218            transfer_type, speed, max_packet_size);
     219        if (ret != EOK) {
     220                free(ep);
     221                return ret;
     222        }
     223
    161224        usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
    162225            address, endpoint, usb_str_transfer_type(transfer_type),
    163226            usb_str_speed(speed), direction, size, max_packet_size, interval);
    164         // TODO use real endpoint here!
    165         return usb_endpoint_manager_register_ep(&hc->ep_manager,NULL, 0);
    166 }
    167 /*----------------------------------------------------------------------------*/
    168 /** Unregister endpoint (free some bandwidth reservation).
    169  *
    170  * @param[in] fun Device function the action was invoked on.
    171  * @param[in] address USB address of the device.
    172  * @param[in] endpoint Endpoint number.
    173  * @param[in] direction Endpoint data direction.
    174  * @return Error code.
    175  */
     227
     228        ret = usb_endpoint_manager_register_ep(&hc->ep_manager, ep, size);
     229        if (ret != EOK) {
     230                endpoint_destroy(ep);
     231        } else {
     232                usb_device_keeper_add_ep(&hc->manager, address, ep);
     233        }
     234        return ret;
     235}
     236/*----------------------------------------------------------------------------*/
    176237static int unregister_endpoint(
    177238    ddf_fun_t *fun, usb_address_t address,
    178239    usb_endpoint_t endpoint, usb_direction_t direction)
    179240{
    180         assert(fun);
    181241        hc_t *hc = fun_to_hc(fun);
    182242        assert(hc);
    … …  
    187247}
    188248/*----------------------------------------------------------------------------*/
    189 /** Schedule interrupt out transfer.
    190  *
    191  * The callback is supposed to be called once the transfer (on the wire) is
    192  * complete regardless of the outcome.
    193  * However, the callback could be called only when this function returns
    194  * with success status (i.e. returns EOK).
    195  *
    196  * @param[in] fun Device function the action was invoked on.
    197  * @param[in] target Target pipe (address and endpoint number) specification.
    198  * @param[in] max_packet_size Max packet size for the transfer.
    199  * @param[in] data Data to be sent (in USB endianess, allocated and deallocated
    200  *      by the caller).
    201  * @param[in] size Size of the @p data buffer in bytes.
    202  * @param[in] callback Callback to be issued once the transfer is complete.
    203  * @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.
    204258 * @return Error code.
    205259 */
    … …  
    208262    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    209263{
    210         assert(fun);
    211         hc_t *hc = fun_to_hc(fun);
    212         assert(hc);
    213         usb_speed_t speed =
    214             usb_device_keeper_get_speed(&hc->manager, target.address);
    215 
    216         usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
    217             target.address, target.endpoint, size, max_packet_size);
    218 
    219         usb_transfer_batch_t *batch =
    220             batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
    221                 speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
    222         if (!batch)
    223                 return ENOMEM;
     264        usb_transfer_batch_t *batch = NULL;
     265        hc_t *hc = NULL;
     266        int ret = setup_batch(fun, target, USB_DIRECTION_OUT, data, size,
     267            NULL, 0, NULL, callback, arg, "Interrupt OUT", &hc, &batch);
     268        if (ret != EOK)
     269                return ret;
    224270        batch_interrupt_out(batch);
    225         const int ret = hc_schedule(hc, batch);
    226         if (ret != EOK) {
    227                 batch_dispose(batch);
    228         }
    229         return ret;
    230 }
    231 /*----------------------------------------------------------------------------*/
    232 /** Schedule interrupt in transfer.
    233  *
    234  * The callback is supposed to be called once the transfer (on the wire) is
    235  * complete regardless of the outcome.
    236  * However, the callback could be called only when this function returns
    237  * with success status (i.e. returns EOK).
    238  *
    239  * @param[in] fun Device function the action was invoked on.
    240  * @param[in] target Target pipe (address and endpoint number) specification.
    241  * @param[in] max_packet_size Max packet size for the transfer.
    242  * @param[in] data Buffer where to store the data (in USB endianess,
    243  *      allocated and deallocated by the caller).
    244  * @param[in] size Size of the @p data buffer in bytes.
    245  * @param[in] callback Callback to be issued once the transfer is complete.
    246  * @param[in] arg Pass-through argument to the callback.
     271        ret = hc_schedule(hc, batch);
     272        if (ret != EOK) {
     273                batch_dispose(batch);
     274        }
     275        return ret;
     276}
     277/*----------------------------------------------------------------------------*/
     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.
    247287 * @return Error code.
    248288 */
    … …  
    251291    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    252292{
    253         assert(fun);
    254         hc_t *hc = fun_to_hc(fun);
    255         assert(hc);
    256         usb_speed_t speed =
    257             usb_device_keeper_get_speed(&hc->manager, target.address);
    258         usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
    259             target.address, target.endpoint, size, max_packet_size);
    260 
    261         usb_transfer_batch_t *batch =
    262             batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
    263                 speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
    264         if (!batch)
    265                 return ENOMEM;
     293        usb_transfer_batch_t *batch = NULL;
     294        hc_t *hc = NULL;
     295        int ret = setup_batch(fun, target, USB_DIRECTION_IN, data, size,
     296            NULL, 0, callback, NULL, arg, "Interrupt IN", &hc, &batch);
     297        if (ret != EOK)
     298                return ret;
    266299        batch_interrupt_in(batch);
    267         const int ret = hc_schedule(hc, batch);
    268         if (ret != EOK) {
    269                 batch_dispose(batch);
    270         }
    271         return ret;
    272 }
    273 /*----------------------------------------------------------------------------*/
    274 /** Schedule bulk out transfer.
    275  *
    276  * The callback is supposed to be called once the transfer (on the wire) is
    277  * complete regardless of the outcome.
    278  * However, the callback could be called only when this function returns
    279  * with success status (i.e. returns EOK).
    280  *
    281  * @param[in] fun Device function the action was invoked on.
    282  * @param[in] target Target pipe (address and endpoint number) specification.
    283  * @param[in] max_packet_size Max packet size for the transfer.
    284  * @param[in] data Data to be sent (in USB endianess, allocated and deallocated
    285  *      by the caller).
    286  * @param[in] size Size of the @p data buffer in bytes.
    287  * @param[in] callback Callback to be issued once the transfer is complete.
    288  * @param[in] arg Pass-through argument to the callback.
     300        ret = hc_schedule(hc, batch);
     301        if (ret != EOK) {
     302                batch_dispose(batch);
     303        }
     304        return ret;
     305}
     306/*----------------------------------------------------------------------------*/
     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.
    289316 * @return Error code.
    290317 */
    … …  
    293320    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
    294321{
    295         assert(fun);
    296         hc_t *hc = fun_to_hc(fun);
    297         assert(hc);
    298         usb_speed_t speed =
    299             usb_device_keeper_get_speed(&hc->manager, target.address);
    300 
    301         usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
    302             target.address, target.endpoint, size, max_packet_size);
    303 
    304         usb_transfer_batch_t *batch =
    305             batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
    306                 data, size, NULL, 0, NULL, callback, arg, &hc->manager);
    307         if (!batch)
    308                 return ENOMEM;
     322        usb_transfer_batch_t *batch = NULL;
     323        hc_t *hc = NULL;
     324        int ret = setup_batch(fun, target, USB_DIRECTION_OUT, data, size,
     325            NULL, 0, NULL, callback, arg, "Bulk OUT", &hc, &batch);
     326        if (ret != EOK)
     327                return ret;
    309328        batch_bulk_out(batch);
    310         const int ret = hc_schedule(hc, batch);
    311         if (ret != EOK) {
    312                 batch_dispose(batch);
    313         }
    314         return ret;
    315 }
    316 /*----------------------------------------------------------------------------*/
    317 /** Schedule bulk in transfer.
    318  *
    319  * The callback is supposed to be called once the transfer (on the wire) is
    320  * complete regardless of the outcome.
    321  * However, the callback could be called only when this function returns
    322  * with success status (i.e. returns EOK).
    323  *
    324  * @param[in] fun Device function the action was invoked on.
    325  * @param[in] target Target pipe (address and endpoint number) specification.
    326  * @param[in] max_packet_size Max packet size for the transfer.
    327  * @param[in] data Buffer where to store the data (in USB endianess,
    328  *      allocated and deallocated by the caller).
    329  * @param[in] size Size of the @p data buffer in bytes.
    330  * @param[in] callback Callback to be issued once the transfer is complete.
    331  * @param[in] arg Pass-through argument to the callback.
     329        ret = hc_schedule(hc, batch);
     330        if (ret != EOK) {
     331                batch_dispose(batch);
     332        }
     333        return ret;
     334}
     335/*----------------------------------------------------------------------------*/
     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.
    332345 * @return Error code.
    333346 */
    … …  
    336349    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
    337350{
    338         assert(fun);
    339         hc_t *hc = fun_to_hc(fun);
    340         assert(hc);
    341         usb_speed_t speed =
    342             usb_device_keeper_get_speed(&hc->manager, target.address);
    343         usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
    344             target.address, target.endpoint, size, max_packet_size);
    345 
    346         usb_transfer_batch_t *batch =
    347             batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
    348                 data, size, NULL, 0, callback, NULL, arg, &hc->manager);
    349         if (!batch)
    350                 return ENOMEM;
     351        usb_transfer_batch_t *batch = NULL;
     352        hc_t *hc = NULL;
     353        int ret = setup_batch(fun, target, USB_DIRECTION_IN, data, size,
     354            NULL, 0, callback, NULL, arg, "Bulk IN", &hc, &batch);
     355        if (ret != EOK)
     356                return ret;
    351357        batch_bulk_in(batch);
    352         const int ret = hc_schedule(hc, batch);
    353         if (ret != EOK) {
    354                 batch_dispose(batch);
    355         }
    356         return ret;
    357 }
    358 /*----------------------------------------------------------------------------*/
    359 /** Schedule control write transfer.
    360  *
    361  * The callback is supposed to be called once the transfer (on the wire) is
    362  * complete regardless of the outcome.
    363  * However, the callback could be called only when this function returns
    364  * with success status (i.e. returns EOK).
    365  *
    366  * @param[in] fun Device function the action was invoked on.
    367  * @param[in] target Target pipe (address and endpoint number) specification.
    368  * @param[in] max_packet_size Max packet size for the transfer.
    369  * @param[in] setup_packet Setup packet buffer (in USB endianess, allocated
    370  *      and deallocated by the caller).
    371  * @param[in] setup_packet_size Size of @p setup_packet buffer in bytes.
    372  * @param[in] data_buffer Data buffer (in USB endianess, allocated and
    373  *      deallocated by the caller).
    374  * @param[in] data_buffer_size Size of @p data_buffer buffer in bytes.
    375  * @param[in] callback Callback to be issued once the transfer is complete.
    376  * @param[in] arg Pass-through argument to the callback.
     358        ret = hc_schedule(hc, batch);
     359        if (ret != EOK) {
     360                batch_dispose(batch);
     361        }
     362        return ret;
     363}
     364/*----------------------------------------------------------------------------*/
     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.
    377376 * @return Error code.
    378377 */
    … …  
    382381    usbhc_iface_transfer_out_callback_t callback, void *arg)
    383382{
    384         assert(fun);
    385         hc_t *hc = fun_to_hc(fun);
    386         assert(hc);
    387         usb_speed_t speed =
    388             usb_device_keeper_get_speed(&hc->manager, target.address);
    389         usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
    390             speed, target.address, target.endpoint, size, max_packet_size);
    391 
    392         if (setup_size != 8)
    393                 return EINVAL;
    394 
    395         usb_transfer_batch_t *batch =
    396             batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size,
    397                 speed, data, size, setup_data, setup_size, NULL, callback, arg,
    398                 &hc->manager);
    399         if (!batch)
    400                 return ENOMEM;
     383        usb_transfer_batch_t *batch = NULL;
     384        hc_t *hc = NULL;
     385        int ret = setup_batch(fun, target, USB_DIRECTION_BOTH, data, size,
     386            setup_data, setup_size, NULL, callback, arg, "Control WRITE",
     387            &hc, &batch);
     388        if (ret != EOK)
     389                return ret;
    401390        usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
    402391        batch_control_write(batch);
    403         const int ret = hc_schedule(hc, batch);
    404         if (ret != EOK) {
    405                 batch_dispose(batch);
    406         }
    407         return ret;
    408 }
    409 /*----------------------------------------------------------------------------*/
    410 /** Schedule control read transfer.
    411  *
    412  * The callback is supposed to be called once the transfer (on the wire) is
    413  * complete regardless of the outcome.
    414  * However, the callback could be called only when this function returns
    415  * with success status (i.e. returns EOK).
    416  *
    417  * @param[in] fun Device function the action was invoked on.
    418  * @param[in] target Target pipe (address and endpoint number) specification.
    419  * @param[in] max_packet_size Max packet size for the transfer.
    420  * @param[in] setup_packet Setup packet buffer (in USB endianess, allocated
    421  *      and deallocated by the caller).
    422  * @param[in] setup_packet_size Size of @p setup_packet buffer in bytes.
    423  * @param[in] data_buffer Buffer where to store the data (in USB endianess,
    424  *      allocated and deallocated by the caller).
    425  * @param[in] data_buffer_size Size of @p data_buffer buffer in bytes.
    426  * @param[in] callback Callback to be issued once the transfer is complete.
    427  * @param[in] arg Pass-through argument to the callback.
     392        ret = hc_schedule(hc, batch);
     393        if (ret != EOK) {
     394                batch_dispose(batch);
     395        }
     396        return ret;
     397}
     398/*----------------------------------------------------------------------------*/
     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.
    428410 * @return Error code.
    429411 */
    … …  
    433415    usbhc_iface_transfer_in_callback_t callback, void *arg)
    434416{
    435         assert(fun);
    436         hc_t *hc = fun_to_hc(fun);
    437         assert(hc);
    438         usb_speed_t speed =
    439             usb_device_keeper_get_speed(&hc->manager, target.address);
    440 
    441         usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
    442             speed, target.address, target.endpoint, size, max_packet_size);
    443         usb_transfer_batch_t *batch =
    444             batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size,
    445                 speed, data, size, setup_data, setup_size, callback, NULL, arg,
    446                 &hc->manager);
    447         if (!batch)
    448                 return ENOMEM;
     417        usb_transfer_batch_t *batch = NULL;
     418        hc_t *hc = NULL;
     419        int ret = setup_batch(fun, target, USB_DIRECTION_BOTH, data, size,
     420            setup_data, setup_size, callback, NULL, arg, "Control READ",
     421            &hc, &batch);
     422        if (ret != EOK)
     423                return ret;
    449424        batch_control_read(batch);
    450         const int ret = hc_schedule(hc, batch);
    451         if (ret != EOK) {
    452                 batch_dispose(batch);
    453         }
    454         return ret;
    455 }
    456 /*----------------------------------------------------------------------------*/
    457 /** Host controller interface implementation for OHCI. */
     425        ret = hc_schedule(hc, batch);
     426        if (ret != EOK) {
     427                batch_dispose(batch);
     428        }
     429        return ret;
     430}
     431/*----------------------------------------------------------------------------*/
    458432usbhc_iface_t hc_iface = {
    459433        .reserve_default_address = reserve_default_address,
    … …  
    475449        .control_read = control_read,
    476450};
    477 
    478451/**
    479452 * @}
Note: See TracChangeset for help on using the changeset viewer.