Changes in / [dcaf819:6bf9bc4] in mainline


Ignore:
Location:
uspace
Files:
2 added
7 deleted
17 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/batch.c

    rdcaf819 r6bf9bc4  
    7373        CHECK_NULL_DISPOSE_RETURN(instance,
    7474            "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);
     75        usb_transfer_batch_init(instance, target, transfer_type, speed, max_packet_size,
     76            buffer, NULL, buffer_size, NULL, setup_size, func_in,
     77            func_out, arg, fun, NULL);
    7878
    7979        if (buffer_size > 0) {

  • uspace/drv/ohci/hc.c

    rdcaf819 r6bf9bc4  
    9292        instance->ddf_instance = fun;
    9393        usb_device_keeper_init(&instance->manager);
    94         ret = usb_endpoint_manager_init(&instance->ep_manager,
    95             BANDWIDTH_AVAILABLE_USB11);
    96         CHECK_RET_RETURN(ret, "Failed to initialize endpoint manager: %s.\n",
     94        ret = bandwidth_init(&instance->bandwidth, BANDWIDTH_AVAILABLE_USB11,
     95            bandwidth_count_usb11);
     96        CHECK_RET_RETURN(ret, "Failed to initialize bandwidth allocator: %s.\n",
    9797            ret, str_error(ret));
    9898

  • uspace/drv/ohci/hc.h

    rdcaf819 r6bf9bc4  
    4242#include <usb/usb.h>
    4343#include <usb/host/device_keeper.h>
    44 #include <usb/host/usb_endpoint_manager.h>
     44#include <usb/host/bandwidth.h>
    4545#include <usbhc_iface.h>
    4646
    … …  
    5555        ddf_fun_t *ddf_instance;
    5656        usb_device_keeper_t manager;
    57         usb_endpoint_manager_t ep_manager;
     57        bandwidth_t bandwidth;
    5858        fid_t interrupt_emulator;
    5959} hc_t;

  • uspace/drv/ohci/iface.c

    rdcaf819 r6bf9bc4  
    162162            address, endpoint, usb_str_transfer_type(transfer_type),
    163163            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,
    166             address, endpoint, direction, NULL, 0);
     164        return bandwidth_reserve(&hc->bandwidth, address, endpoint, direction,
     165            speed, transfer_type, max_packet_size, size, interval);
    167166}
    168167/*----------------------------------------------------------------------------*/
    … …  
    184183        usb_log_debug("Unregister endpoint %d:%d %d.\n",
    185184            address, endpoint, direction);
    186         return usb_endpoint_manager_unregister_ep(&hc->ep_manager, address,
    187             endpoint, direction);
     185        return bandwidth_release(&hc->bandwidth, address, endpoint, direction);
     186
     187        return ENOTSUP;
    188188}
    189189/*----------------------------------------------------------------------------*/

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

    rdcaf819 r6bf9bc4  
    4949        td_t *tds;
    5050        size_t transfers;
     51        usb_device_keeper_t *manager;
    5152} uhci_batch_t;
    5253
    … …  
    7273 * @param[in] func_out function to call on outbound transaction completion
    7374 * @param[in] arg additional parameter to func_in or func_out
    74  * @param[in] ep Pointer to endpoint toggle management structure.
     75 * @param[in] manager Pointer to toggle management structure.
    7576 * @return Valid pointer if all substructures were successfully created,
    7677 * NULL otherwise.
    … …  
    8586    char* setup_buffer, size_t setup_size,
    8687    usbhc_iface_transfer_in_callback_t func_in,
    87     usbhc_iface_transfer_out_callback_t func_out, void *arg, endpoint_t *ep
     88    usbhc_iface_transfer_out_callback_t func_out, void *arg,
     89    usb_device_keeper_t *manager
    8890    )
    8991{
    … …  
    103105        CHECK_NULL_DISPOSE_RETURN(instance,
    104106            "Failed to allocate batch instance.\n");
    105         usb_transfer_batch_init(instance, target,
    106             transfer_type, speed, max_packet_size,
     107        usb_transfer_batch_init(instance, target, transfer_type, speed, max_packet_size,
    107108            buffer, NULL, buffer_size, NULL, setup_size, func_in,
    108             func_out, arg, fun, ep, NULL);
     109            func_out, arg, fun, NULL);
    109110
    110111
    … …  
    113114            "Failed to allocate batch instance.\n");
    114115        bzero(data, sizeof(uhci_batch_t));
     116        data->manager = manager;
    115117        instance->private_data = data;
    116118
    … …  
    178180                            instance, i, data->tds[i].status);
    179181                        td_print_status(&data->tds[i]);
    180                         if (instance->ep != NULL)
    181                                 endpoint_toggle_set(instance->ep,
    182                                     td_toggle(&data->tds[i]));
     182
     183                        usb_device_keeper_set_toggle(data->manager,
     184                            instance->target, instance->direction,
     185                            td_toggle(&data->tds[i]));
    183186                        if (i > 0)
    184187                                goto substract_ret;
    … …  
    307310
    308311        const bool low_speed = instance->speed == USB_SPEED_LOW;
    309         int toggle = endpoint_toggle_get(instance->ep);
     312        int toggle = usb_device_keeper_get_toggle(
     313            data->manager, instance->target, instance->direction);
    310314        assert(toggle == 0 || toggle == 1);
    311315
    … …  
    338342        }
    339343        td_set_ioc(&data->tds[transfer - 1]);
    340         endpoint_toggle_set(instance->ep, toggle);
     344        usb_device_keeper_set_toggle(data->manager, instance->target,
     345            instance->direction, toggle);
    341346}
    342347/*----------------------------------------------------------------------------*/

  • uspace/drv/uhci-hcd/batch.h

    rdcaf819 r6bf9bc4  
    3535#define DRV_UHCI_BATCH_H
    3636
     37#include <adt/list.h>
     38
    3739#include <usbhc_iface.h>
    3840#include <usb/usb.h>
    3941#include <usb/host/device_keeper.h>
    40 #include <usb/host/endpoint.h>
    4142#include <usb/host/batch.h>
    4243
    … …  
    5657    usbhc_iface_transfer_out_callback_t func_out,
    5758                void *arg,
    58                 endpoint_t *ep
     59                usb_device_keeper_t *manager
    5960                );
    6061

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

    rdcaf819 r6bf9bc4  
    6666static int hc_interrupt_emulator(void *arg);
    6767static int hc_debug_checker(void *arg);
    68 #if 0
     68
    6969static bool usb_is_allowed(
    7070    bool low_speed, usb_transfer_type_t transfer, size_t size);
    71 #endif
    7271/*----------------------------------------------------------------------------*/
    7372/** Initialize UHCI hcd driver structure
    … …  
    240239        usb_log_debug("Initialized device manager.\n");
    241240
    242         ret =
    243             usb_endpoint_manager_init(&instance->ep_manager,
    244                 BANDWIDTH_AVAILABLE_USB11);
     241        ret = bandwidth_init(&instance->bandwidth, BANDWIDTH_AVAILABLE_USB11,
     242            bandwidth_count_usb11);
    245243        assert(ret == EOK);
    246244
    … …  
    328326        assert(instance);
    329327        assert(batch);
     328        const int low_speed = (batch->speed == USB_SPEED_LOW);
     329        if (!usb_is_allowed(
     330            low_speed, batch->transfer_type, batch->max_packet_size)) {
     331                usb_log_error("Invalid USB transfer specified %s %d %zu.\n",
     332                    usb_str_speed(batch->speed), batch->transfer_type,
     333                    batch->max_packet_size);
     334                return ENOTSUP;
     335        }
     336        /* Check available bandwidth */
     337        if (batch->transfer_type == USB_TRANSFER_INTERRUPT ||
     338            batch->transfer_type == USB_TRANSFER_ISOCHRONOUS) {
     339                size_t bw = bandwidth_count_usb11(batch->speed,
     340                    batch->transfer_type, batch->buffer_size,
     341                    batch->max_packet_size);
     342                int ret =
     343                    bandwidth_use(&instance->bandwidth, batch->target.address,
     344                    batch->target.endpoint, batch->direction, bw);
     345                if (ret != EOK) {
     346                        usb_log_error("Failed(%d) to use reserved bw: %s.\n",
     347                            ret, str_error(ret));
     348                        return ret;
     349                }
     350        }
    330351
    331352        transfer_list_t *list =
    … …  
    381402                        case USB_TRANSFER_INTERRUPT:
    382403                        case USB_TRANSFER_ISOCHRONOUS: {
    383 /*
    384404                                int ret = bandwidth_free(&instance->bandwidth,
    385405                                    batch->target.address,
    … …  
    390410                                            "reserved bw: %s.\n", ret,
    391411                                            str_error(ret));
    392 */
    393412                                }
    394413                        default:
    … …  
    514533 * @return True if transaction is allowed by USB specs, false otherwise
    515534 */
    516 #if 0
    517535bool usb_is_allowed(
    518536    bool low_speed, usb_transfer_type_t transfer, size_t size)
    … …  
    532550        return false;
    533551}
    534 #endif
    535552/**
    536553 * @}

  • uspace/drv/uhci-hcd/hc.h

    rdcaf819 r6bf9bc4  
    4343#include <usbhc_iface.h>
    4444#include <usb/host/device_keeper.h>
    45 #include <usb/host/usb_endpoint_manager.h>
     45#include <usb/host/bandwidth.h>
    4646
    4747#include "batch.h"
    … …  
    8585typedef struct hc {
    8686        usb_device_keeper_t manager;
    87         usb_endpoint_manager_t ep_manager;
     87        bandwidth_t bandwidth;
    8888
    8989        regs_t *registers;

  • uspace/drv/uhci-hcd/hw_struct/queue_head.h

    rdcaf819 r6bf9bc4  
    3939
    4040#include "link_pointer.h"
     41#include "utils/malloc32.h"
    4142
    4243typedef struct queue_head {

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

    rdcaf819 r6bf9bc4  
    3636
    3737#include <usb/debug.h>
    38 #include <usb/host/endpoint.h>
    3938
    4039#include "iface.h"
    … …  
    5554        usb_device_keeper_reserve_default_address(&hc->manager, speed);
    5655        return EOK;
    57 #if 0
    58         endpoint_t *ep = malloc(sizeof(endpoint_t));
    59         if (ep == NULL)
    60                 return ENOMEM;
    61         const size_t max_packet_size = speed == USB_SPEED_LOW ? 8 : 64;
    62         endpoint_init(ep, USB_TRANSFER_CONTROL, speed, max_packet_size);
    63         int ret;
    64 try_retgister:
    65         ret = usb_endpoint_manager_register_ep(&hc->ep_manager,
    66             USB_ADDRESS_DEFAULT, 0, USB_DIRECTION_BOTH, ep, endpoint_destroy, 0);
    67         if (ret == EEXISTS) {
    68                 async_usleep(1000);
    69                 goto try_retgister;
    70         }
    71         if (ret != EOK) {
    72                 endpoint_destroy(ep);
    73         }
    74         return ret;
    75 #endif
    7656}
    7757/*----------------------------------------------------------------------------*/
    … …  
    8767        assert(hc);
    8868        usb_log_debug("Default address release.\n");
    89 //      return usb_endpoint_manager_unregister_ep(&hc->ep_manager,
    90 //          USB_ADDRESS_DEFAULT, 0, USB_DIRECTION_BOTH);
    9169        usb_device_keeper_release_default_address(&hc->manager);
    9270        return EOK;
    … …  
    159137        const usb_speed_t speed =
    160138            usb_device_keeper_get_speed(&hc->manager, address);
    161         const size_t size =
    162             (transfer_type == USB_TRANSFER_INTERRUPT
    163             || transfer_type == USB_TRANSFER_ISOCHRONOUS) ?
    164             max_packet_size : 0;
    165         int ret;
    166 
    167         endpoint_t *ep = malloc(sizeof(endpoint_t));
    168         if (ep == NULL)
    169                 return ENOMEM;
    170         ret = endpoint_init(ep, transfer_type, speed, max_packet_size);
    171         if (ret != EOK) {
    172                 free(ep);
    173                 return ret;
    174         }
     139        size_t size = max_packet_size;
    175140
    176141        usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
    177142            address, endpoint, usb_str_transfer_type(transfer_type),
    178143            usb_str_speed(speed), direction, size, max_packet_size, interval);
    179 
    180         ret = usb_endpoint_manager_register_ep(&hc->ep_manager,
    181             address, endpoint, direction, ep, size);
    182         if (ret != EOK) {
    183                 endpoint_destroy(ep);
    184         } else {
    185                 usb_device_keeper_add_ep(&hc->manager, address, ep);
    186         }
    187         return ret;
     144        return bandwidth_reserve(&hc->bandwidth, address, endpoint, direction,
     145            speed, transfer_type, max_packet_size, size, interval);
    188146}
    189147/*----------------------------------------------------------------------------*/
    … …  
    196154        usb_log_debug("Unregister endpoint %d:%d %d.\n",
    197155            address, endpoint, direction);
    198         return usb_endpoint_manager_unregister_ep(&hc->ep_manager, address,
    199             endpoint, direction);
     156        return bandwidth_release(&hc->bandwidth, address, endpoint, direction);
    200157}
    201158/*----------------------------------------------------------------------------*/
    … …  
    218175        hc_t *hc = fun_to_hc(fun);
    219176        assert(hc);
     177        usb_speed_t speed =
     178            usb_device_keeper_get_speed(&hc->manager, target.address);
    220179
    221180        usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
    222181            target.address, target.endpoint, size, max_packet_size);
    223182
    224         size_t res_bw;
    225         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    226             target.address, target.endpoint, USB_DIRECTION_OUT, &res_bw);
    227         if (ep == NULL) {
    228                 usb_log_error("Endpoint(%d:%d) not registered for INT OUT.\n",
    229                         target.address, target.endpoint);
    230                 return ENOENT;
    231         }
    232         const size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
    233             size, ep->max_packet_size);
    234         if (res_bw < bw)
    235         {
    236                 usb_log_error("Endpoint(%d:%d) INT IN needs %zu bw "
    237                     "but only %zu is reserved.\n",
    238                     target.address, target.endpoint, bw, res_bw);
    239                 return ENOENT;
    240         }
    241         assert(ep->speed ==
    242             usb_device_keeper_get_speed(&hc->manager, target.address));
    243         assert(ep->max_packet_size == max_packet_size);
    244         assert(ep->transfer_type == USB_TRANSFER_INTERRUPT);
    245 
    246         usb_transfer_batch_t *batch =
    247             batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    248                 ep->speed, data, size, NULL, 0, NULL, callback, arg, ep);
     183        usb_transfer_batch_t *batch =
     184            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
     185                speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
    249186        if (!batch)
    250187                return ENOMEM;
    … …  
    275212        hc_t *hc = fun_to_hc(fun);
    276213        assert(hc);
    277 
     214        usb_speed_t speed =
     215            usb_device_keeper_get_speed(&hc->manager, target.address);
    278216        usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
    279217            target.address, target.endpoint, size, max_packet_size);
    280218
    281         size_t res_bw;
    282         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    283             target.address, target.endpoint, USB_DIRECTION_IN, &res_bw);
    284         if (ep == NULL) {
    285                 usb_log_error("Endpoint(%d:%d) not registered for INT IN.\n",
    286                     target.address, target.endpoint);
    287                 return ENOENT;
    288         }
    289         const size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
    290             size, ep->max_packet_size);
    291         if (res_bw < bw)
    292         {
    293                 usb_log_error("Endpoint(%d:%d) INT IN needs %zu bw "
    294                     "but only %zu bw is reserved.\n",
    295                     target.address, target.endpoint, bw, res_bw);
    296                 return ENOENT;
    297         }
    298 
    299         assert(ep->speed ==
    300             usb_device_keeper_get_speed(&hc->manager, target.address));
    301         assert(ep->max_packet_size == max_packet_size);
    302         assert(ep->transfer_type == USB_TRANSFER_INTERRUPT);
    303 
    304         usb_transfer_batch_t *batch =
    305             batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    306                 ep->speed, data, size, NULL, 0, callback, NULL, arg, ep);
     219        usb_transfer_batch_t *batch =
     220            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
     221                speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
    307222        if (!batch)
    308223                return ENOMEM;
    … …  
    333248        hc_t *hc = fun_to_hc(fun);
    334249        assert(hc);
     250        usb_speed_t speed =
     251            usb_device_keeper_get_speed(&hc->manager, target.address);
    335252
    336253        usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
    337254            target.address, target.endpoint, size, max_packet_size);
    338255
    339         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    340             target.address, target.endpoint, USB_DIRECTION_OUT, NULL);
    341         if (ep == NULL) {
    342                 usb_log_error("Endpoint(%d:%d) not registered for BULK OUT.\n",
    343                         target.address, target.endpoint);
    344                 return ENOENT;
    345         }
    346         assert(ep->speed ==
    347             usb_device_keeper_get_speed(&hc->manager, target.address));
    348         assert(ep->max_packet_size == max_packet_size);
    349         assert(ep->transfer_type == USB_TRANSFER_BULK);
    350 
    351         usb_transfer_batch_t *batch =
    352             batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    353                 ep->speed, data, size, NULL, 0, NULL, callback, arg, ep);
     256        usb_transfer_batch_t *batch =
     257            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
     258                data, size, NULL, 0, NULL, callback, arg, &hc->manager);
    354259        if (!batch)
    355260                return ENOMEM;
    … …  
    380285        hc_t *hc = fun_to_hc(fun);
    381286        assert(hc);
     287        usb_speed_t speed =
     288            usb_device_keeper_get_speed(&hc->manager, target.address);
    382289        usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
    383290            target.address, target.endpoint, size, max_packet_size);
    384291
    385         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    386             target.address, target.endpoint, USB_DIRECTION_IN, NULL);
    387         if (ep == NULL) {
    388                 usb_log_error("Endpoint(%d:%d) not registered for BULK IN.\n",
    389                         target.address, target.endpoint);
    390                 return ENOENT;
    391         }
    392         assert(ep->speed ==
    393             usb_device_keeper_get_speed(&hc->manager, target.address));
    394         assert(ep->max_packet_size == max_packet_size);
    395         assert(ep->transfer_type == USB_TRANSFER_BULK);
    396 
    397         usb_transfer_batch_t *batch =
    398             batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    399                 ep->speed, data, size, NULL, 0, callback, NULL, arg, ep);
     292        usb_transfer_batch_t *batch =
     293            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
     294                data, size, NULL, 0, callback, NULL, arg, &hc->manager);
    400295        if (!batch)
    401296                return ENOMEM;
    … …  
    433328        usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
    434329            speed, target.address, target.endpoint, size, max_packet_size);
    435         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    436             target.address, target.endpoint, USB_DIRECTION_BOTH, NULL);
    437         if (ep == NULL) {
    438                 usb_log_warning("Endpoint(%d:%d) not registered for CONTROL.\n",
    439                         target.address, target.endpoint);
    440         }
    441330
    442331        if (setup_size != 8)
    … …  
    445334        usb_transfer_batch_t *batch =
    446335            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
    447                 data, size, setup_data, setup_size, NULL, callback, arg, ep);
     336                data, size, setup_data, setup_size, NULL, callback, arg,
     337                &hc->manager);
    448338        if (!batch)
    449339                return ENOMEM;
    … …  
    483373        usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
    484374            speed, target.address, target.endpoint, size, max_packet_size);
    485         endpoint_t *ep = usb_endpoint_manager_get_ep(&hc->ep_manager,
    486             target.address, target.endpoint, USB_DIRECTION_BOTH, NULL);
    487         if (ep == NULL) {
    488                 usb_log_warning("Endpoint(%d:%d) not registered for CONTROL.\n",
    489                         target.address, target.endpoint);
    490         }
    491375        usb_transfer_batch_t *batch =
    492376            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
    493                 data, size, setup_data, setup_size, callback, NULL, arg, ep);
     377                data, size, setup_data, setup_size, callback, NULL, arg,
     378                &hc->manager);
    494379        if (!batch)
    495380                return ENOMEM;

  • uspace/drv/uhci-hcd/transfer_list.h

    rdcaf819 r6bf9bc4  
    3939#include "batch.h"
    4040#include "hw_struct/queue_head.h"
    41 #include "utils/malloc32.h"
    4241
    4342typedef struct transfer_list

  • uspace/drv/uhci-hcd/utils/malloc32.h

    rdcaf819 r6bf9bc4  
    3636
    3737#include <assert.h>
    38 #include <errno.h>
    3938#include <malloc.h>
    4039#include <mem.h>

  • uspace/lib/usb/Makefile

    rdcaf819 r6bf9bc4  
    5454        src/host/device_keeper.c \
    5555        src/host/batch.c \
    56         src/host/endpoint.c \
    57         src/host/usb_endpoint_manager.c
     56        src/host/bandwidth.c
    5857
    5958include $(USPACE_PREFIX)/Makefile.common

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

    rdcaf819 r6bf9bc4  
    3939#include <usbhc_iface.h>
    4040#include <usb/usb.h>
    41 #include <usb/host/endpoint.h>
    4241
    4342typedef struct usb_transfer_batch usb_transfer_batch_t;
    … …  
    6160        ddf_fun_t *fun;
    6261        void *arg;
    63         endpoint_t *ep;
    6462        void *private_data;
    6563};
    … …  
    8078    void *arg,
    8179    ddf_fun_t *fun,
    82                 endpoint_t *ep,
    8380    void *private_data
    8481);

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

    rdcaf819 r6bf9bc4  
    4040#ifndef LIBUSB_HOST_DEVICE_KEEPER_H
    4141#define LIBUSB_HOST_DEVICE_KEEPER_H
    42 
    43 #include <adt/list.h>
    4442#include <devman.h>
    4543#include <fibril_synch.h>
    4644#include <usb/usb.h>
    47 #include <usb/host/endpoint.h>
    4845
    4946/** Number of USB address for array dimensions. */
    … …  
    5451        usb_speed_t speed;
    5552        bool occupied;
    56         link_t endpoints;
    5753        uint16_t control_used;
     54        uint16_t toggle_status[2];
    5855        devman_handle_t handle;
    5956};
    … …  
    7168void usb_device_keeper_init(usb_device_keeper_t *instance);
    7269
    73 void usb_device_keeper_add_ep(
    74     usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep);
    75 
    76 void usb_device_keeper_reserve_default_address(
    77     usb_device_keeper_t *instance, usb_speed_t speed);
     70void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance,
     71    usb_speed_t speed);
    7872
    7973void usb_device_keeper_release_default_address(usb_device_keeper_t *instance);
    8074
    8175void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
    82     usb_target_t target, const uint8_t *setup_data);
     76    usb_target_t target,
     77    const uint8_t *setup_data);
     78
     79int usb_device_keeper_get_toggle(usb_device_keeper_t *instance,
     80    usb_target_t target, usb_direction_t direction);
     81
     82int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
     83    usb_target_t target, usb_direction_t direction, bool toggle);
    8384
    8485usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,

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

    rdcaf819 r6bf9bc4  
    5454    void *arg,
    5555    ddf_fun_t *fun,
    56                 endpoint_t *ep,
    5756    void *private_data
    5857    )
    … …  
    7877        instance->next_step = NULL;
    7978        instance->error = EOK;
    80         instance->ep = ep;
     79
    8180}
    8281/*----------------------------------------------------------------------------*/

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

    rdcaf819 r6bf9bc4  
    5656                instance->devices[i].control_used = 0;
    5757                instance->devices[i].handle = 0;
    58                 list_initialize(&instance->devices[i].endpoints);
    59         }
    60 }
    61 /*----------------------------------------------------------------------------*/
    62 void usb_device_keeper_add_ep(
    63     usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep)
    64 {
    65         assert(instance);
    66         fibril_mutex_lock(&instance->guard);
    67         assert(instance->devices[address].occupied);
    68         list_append(&ep->same_device_eps, &instance->devices[address].endpoints);
    69         fibril_mutex_unlock(&instance->guard);
     58                instance->devices[i].toggle_status[0] = 0;
     59                instance->devices[i].toggle_status[1] = 0;
     60        }
    7061}
    7162/*----------------------------------------------------------------------------*/
    … …  
    7566 * @param[in] speed Speed of the device requesting default address.
    7667 */
    77 void usb_device_keeper_reserve_default_address(
    78     usb_device_keeper_t *instance, usb_speed_t speed)
     68void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance,
     69    usb_speed_t speed)
    7970{
    8071        assert(instance);
    … …  
    110101 * Really ugly one.
    111102 */
    112 void usb_device_keeper_reset_if_need(
    113     usb_device_keeper_t *instance, usb_target_t target, const uint8_t *data)
     103void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
     104    usb_target_t target, const uint8_t *data)
    114105{
    115106        assert(instance);
    … …  
    129120                if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
    130121                        /* endpoint number is < 16, thus first byte is enough */
    131                         assert(!"NOT IMPLEMENTED!");
     122                        instance->devices[target.address].toggle_status[0] &=
     123                            ~(1 << data[4]);
     124                        instance->devices[target.address].toggle_status[1] &=
     125                            ~(1 << data[4]);
    132126                }
    133127        break;
    … …  
    137131                /* target must be device */
    138132                if ((data[0] & 0xf) == 0) {
    139                         link_t *current =
    140                             instance->devices[target.address].endpoints.next;
    141                         while (current !=
    142                            &instance->devices[target.address].endpoints)
    143                         {
    144                                 endpoint_toggle_reset(current);
    145                                 current = current->next;
    146                         }
     133                        instance->devices[target.address].toggle_status[0] = 0;
     134                        instance->devices[target.address].toggle_status[1] = 0;
    147135                }
    148136        break;
    149137        }
    150138        fibril_mutex_unlock(&instance->guard);
     139}
     140/*----------------------------------------------------------------------------*/
     141/** Get current value of endpoint toggle.
     142 *
     143 * @param[in] instance Device keeper structure to use.
     144 * @param[in] target Device and endpoint used.
     145 * @return Error code
     146 */
     147int usb_device_keeper_get_toggle(usb_device_keeper_t *instance,
     148    usb_target_t target, usb_direction_t direction)
     149{
     150        assert(instance);
     151        /* only control pipes are bi-directional and those do not need toggle */
     152        if (direction == USB_DIRECTION_BOTH)
     153                return ENOENT;
     154        int ret;
     155        fibril_mutex_lock(&instance->guard);
     156        if (target.endpoint > 15 || target.endpoint < 0
     157            || target.address >= USB_ADDRESS_COUNT || target.address < 0
     158            || !instance->devices[target.address].occupied) {
     159                usb_log_error("Invalid data when asking for toggle value.\n");
     160                ret = EINVAL;
     161        } else {
     162                ret = (instance->devices[target.address].toggle_status[direction]
     163                        >> target.endpoint) & 1;
     164        }
     165        fibril_mutex_unlock(&instance->guard);
     166        return ret;
     167}
     168/*----------------------------------------------------------------------------*/
     169/** Set current value of endpoint toggle.
     170 *
     171 * @param[in] instance Device keeper structure to use.
     172 * @param[in] target Device and endpoint used.
     173 * @param[in] toggle Toggle value.
     174 * @return Error code.
     175 */
     176int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
     177    usb_target_t target, usb_direction_t direction, bool toggle)
     178{
     179        assert(instance);
     180        /* only control pipes are bi-directional and those do not need toggle */
     181        if (direction == USB_DIRECTION_BOTH)
     182                return ENOENT;
     183        int ret;
     184        fibril_mutex_lock(&instance->guard);
     185        if (target.endpoint > 15 || target.endpoint < 0
     186            || target.address >= USB_ADDRESS_COUNT || target.address < 0
     187            || !instance->devices[target.address].occupied) {
     188                usb_log_error("Invalid data when setting toggle value.\n");
     189                ret = EINVAL;
     190        } else {
     191                if (toggle) {
     192                        instance->devices[target.address].toggle_status[direction]
     193                            |= (1 << target.endpoint);
     194                } else {
     195                        instance->devices[target.address].toggle_status[direction]
     196                            &= ~(1 << target.endpoint);
     197                }
     198                ret = EOK;
     199        }
     200        fibril_mutex_unlock(&instance->guard);
     201        return ret;
    151202}
    152203/*----------------------------------------------------------------------------*/
    … …  
    157208 * @return Free address, or error code.
    158209 */
    159 usb_address_t device_keeper_get_free_address(
    160     usb_device_keeper_t *instance, usb_speed_t speed)
     210usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,
     211    usb_speed_t speed)
    161212{
    162213        assert(instance);
    … …  
    178229        instance->devices[new_address].occupied = true;
    179230        instance->devices[new_address].speed = speed;
     231        instance->devices[new_address].toggle_status[0] = 0;
     232        instance->devices[new_address].toggle_status[1] = 0;
    180233        instance->last_address = new_address;
    181234        fibril_mutex_unlock(&instance->guard);
    … …  
    206259 * @param[in] address Device address
    207260 */
    208 void usb_device_keeper_release(
    209     usb_device_keeper_t *instance, usb_address_t address)
     261void usb_device_keeper_release(usb_device_keeper_t *instance,
     262    usb_address_t address)
    210263{
    211264        assert(instance);
    … …  
    225278 * @return USB Address, or error code.
    226279 */
    227 usb_address_t usb_device_keeper_find(
    228     usb_device_keeper_t *instance, devman_handle_t handle)
     280usb_address_t usb_device_keeper_find(usb_device_keeper_t *instance,
     281    devman_handle_t handle)
    229282{
    230283        assert(instance);
    … …  
    248301 * @return USB speed.
    249302 */
    250 usb_speed_t usb_device_keeper_get_speed(
    251     usb_device_keeper_t *instance, usb_address_t address)
     303usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
     304    usb_address_t address)
    252305{
    253306        assert(instance);
    … …  
    257310}
    258311/*----------------------------------------------------------------------------*/
    259 void usb_device_keeper_use_control(
    260     usb_device_keeper_t *instance, usb_target_t target)
     312void usb_device_keeper_use_control(usb_device_keeper_t *instance,
     313    usb_target_t target)
    261314{
    262315        assert(instance);
    … …  
    270323}
    271324/*----------------------------------------------------------------------------*/
    272 void usb_device_keeper_release_control(
    273     usb_device_keeper_t *instance, usb_target_t target)
     325void usb_device_keeper_release_control(usb_device_keeper_t *instance,
     326    usb_target_t target)
    274327{
    275328        assert(instance);
Note: See TracChangeset for help on using the changeset viewer.