Changeset f567bcf in mainline


Ignore:
Timestamp:
2011-04-06T22:02:17Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4ca18ae
Parents:
8dc762e0
Message:

Switch to new endpoint toggle control.

Location:
uspace
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/batch.c

    r8dc762e0 rf567bcf  
    7373        CHECK_NULL_DISPOSE_RETURN(instance,
    7474            "Failed to allocate batch instance.\n");
    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);
     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);
    7878
    7979        if (buffer_size > 0) {

  • uspace/drv/ohci/iface.c

    r8dc762e0 rf567bcf  
    164164        // TODO use real endpoint here!
    165165        return usb_endpoint_manager_register_ep(&hc->ep_manager,
    166             address, endpoint, direction, NULL, NULL, 0);
     166            address, endpoint, direction, NULL, 0);
    167167}
    168168/*----------------------------------------------------------------------------*/

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

    r8dc762e0 rf567bcf  
    4949        td_t *tds;
    5050        size_t transfers;
    51         usb_device_keeper_t *manager;
     51//      usb_device_keeper_t *manager;
    5252} uhci_batch_t;
    5353
    … …  
    8787    usbhc_iface_transfer_in_callback_t func_in,
    8888    usbhc_iface_transfer_out_callback_t func_out, void *arg,
    89     usb_device_keeper_t *manager
     89    usb_device_keeper_t *manager, endpoint_t *ep
    9090    )
    9191{
    … …  
    105105        CHECK_NULL_DISPOSE_RETURN(instance,
    106106            "Failed to allocate batch instance.\n");
    107         usb_transfer_batch_init(instance, target, transfer_type, speed, max_packet_size,
     107        usb_transfer_batch_init(instance, target,
     108            transfer_type, speed, max_packet_size,
    108109            buffer, NULL, buffer_size, NULL, setup_size, func_in,
    109             func_out, arg, fun, NULL);
     110            func_out, arg, fun, ep, NULL);
    110111
    111112
    … …  
    114115            "Failed to allocate batch instance.\n");
    115116        bzero(data, sizeof(uhci_batch_t));
    116         data->manager = manager;
     117//      data->manager = manager;
    117118        instance->private_data = data;
    118119
    … …  
    180181                            instance, i, data->tds[i].status);
    181182                        td_print_status(&data->tds[i]);
    182 
     183                        endpoint_toggle_set(instance->ep,
     184                            td_toggle(&data->tds[i]));
     185/*
    183186                        usb_device_keeper_set_toggle(data->manager,
    184187                            instance->target, instance->direction,
    185188                            td_toggle(&data->tds[i]));
     189*/
    186190                        if (i > 0)
    187191                                goto substract_ret;
    … …  
    310314
    311315        const bool low_speed = instance->speed == USB_SPEED_LOW;
    312         int toggle = usb_device_keeper_get_toggle(
    313             data->manager, instance->target, instance->direction);
     316        int toggle = endpoint_toggle_get(instance->ep);
     317//      usb_device_keeper_get_toggle(
     318//          data->manager, instance->target, instance->direction);
    314319        assert(toggle == 0 || toggle == 1);
    315320
    … …  
    342347        }
    343348        td_set_ioc(&data->tds[transfer - 1]);
    344         usb_device_keeper_set_toggle(data->manager, instance->target,
    345             instance->direction, toggle);
     349        endpoint_toggle_set(instance->ep, toggle);
     350//      usb_device_keeper_set_toggle(data->manager, instance->target,
     351//          instance->direction, toggle);
    346352}
    347353/*----------------------------------------------------------------------------*/

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

    r8dc762e0 rf567bcf  
    5656    usbhc_iface_transfer_out_callback_t func_out,
    5757                void *arg,
    58                 usb_device_keeper_t *manager
     58                usb_device_keeper_t *manager,
     59                endpoint_t *ep
    5960                );
    6061

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

    r8dc762e0 rf567bcf  
    183183                endpoint_destroy(ep);
    184184        } else {
    185                 usb_device_keeper_add_ep(&hc->manager, address, &ep->same_device_eps);
     185                usb_device_keeper_add_ep(&hc->manager, address, ep);
    186186        }
    187187        return ret;
    … …  
    246246        usb_transfer_batch_t *batch =
    247247            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    248                 ep->speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
     248                ep->speed, data, size, NULL, 0, NULL, callback, arg,
     249                &hc->manager, ep);
    249250        if (!batch)
    250251                return ENOMEM;
    … …  
    304305        usb_transfer_batch_t *batch =
    305306            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    306                 ep->speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
     307                ep->speed, data, size, NULL, 0, callback, NULL, arg,
     308                &hc->manager, ep);
    307309        if (!batch)
    308310                return ENOMEM;
    … …  
    352354            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    353355                ep->speed, data, size, NULL, 0, NULL, callback, arg,
    354                 &hc->manager);
     356                &hc->manager, ep);
    355357        if (!batch)
    356358                return ENOMEM;
    … …  
    399401            batch_get(fun, target, ep->transfer_type, ep->max_packet_size,
    400402                ep->speed, data, size, NULL, 0, callback, NULL, arg,
    401                 &hc->manager);
     403                &hc->manager, ep);
    402404        if (!batch)
    403405                return ENOMEM;
    … …  
    448450            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
    449451                data, size, setup_data, setup_size, NULL, callback, arg,
    450                 &hc->manager);
     452                &hc->manager, ep);
    451453        if (!batch)
    452454                return ENOMEM;
    … …  
    495497            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
    496498                data, size, setup_data, setup_size, callback, NULL, arg,
    497                 &hc->manager);
     499                &hc->manager, ep);
    498500        if (!batch)
    499501                return ENOMEM;

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

    r8dc762e0 rf567bcf  
    3939#include <usbhc_iface.h>
    4040#include <usb/usb.h>
     41#include <usb/host/endpoint.h>
    4142
    4243typedef struct usb_transfer_batch usb_transfer_batch_t;
    … …  
    6061        ddf_fun_t *fun;
    6162        void *arg;
     63        endpoint_t *ep;
    6264        void *private_data;
    6365};
    … …  
    7880    void *arg,
    7981    ddf_fun_t *fun,
     82                endpoint_t *ep,
    8083    void *private_data
    8184);

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

    r8dc762e0 rf567bcf  
    4545#include <fibril_synch.h>
    4646#include <usb/usb.h>
     47#include <usb/host/endpoint.h>
    4748
    4849/** Number of USB address for array dimensions. */
    … …  
    7273
    7374void usb_device_keeper_add_ep(
    74     usb_device_keeper_t *instance, usb_address_t address, link_t *ep);
     75    usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep);
    7576
    7677void usb_device_keeper_reserve_default_address(
    … …  
    8283    usb_target_t target,
    8384    const uint8_t *setup_data);
    84 
     85/*
    8586int usb_device_keeper_get_toggle(usb_device_keeper_t *instance,
    8687    usb_target_t target, usb_direction_t direction);
    … …  
    8889int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
    8990    usb_target_t target, usb_direction_t direction, bool toggle);
    90 
     91*/
    9192usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,
    9293    usb_speed_t speed);

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

    r8dc762e0 rf567bcf  
    4747        size_t max_packet_size;
    4848        bool active;
    49         int toggle:1;
     49        unsigned toggle:1;
    5050} endpoint_t;
    5151
    … …  
    5555void endpoint_destroy(endpoint_t *instance);
    5656
     57int endpoint_toggle_get(endpoint_t *instance);
     58
     59void endpoint_toggle_set(endpoint_t *instance, int toggle);
     60
    5761void endpoint_toggle_reset(link_t *ep);
     62
    5863
    5964#endif

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

    r8dc762e0 rf567bcf  
    5454    void *arg,
    5555    ddf_fun_t *fun,
     56                endpoint_t *ep,
    5657    void *private_data
    5758    )
    … …  
    7778        instance->next_step = NULL;
    7879        instance->error = EOK;
    79 
     80        instance->ep = ep;
    8081}
    8182/*----------------------------------------------------------------------------*/

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

    r8dc762e0 rf567bcf  
    5656                instance->devices[i].control_used = 0;
    5757                instance->devices[i].handle = 0;
    58                 instance->devices[i].toggle_status[0] = 0;
    59                 instance->devices[i].toggle_status[1] = 0;
     58//              instance->devices[i].toggle_status[0] = 0;
     59//              instance->devices[i].toggle_status[1] = 0;
    6060                list_initialize(&instance->devices[i].endpoints);
    6161        }
    … …  
    6363/*----------------------------------------------------------------------------*/
    6464void usb_device_keeper_add_ep(
    65     usb_device_keeper_t *instance, usb_address_t address, link_t *ep)
     65    usb_device_keeper_t *instance, usb_address_t address, endpoint_t *ep)
    6666{
    6767        assert(instance);
    6868        fibril_mutex_lock(&instance->guard);
    6969        assert(instance->devices[address].occupied);
    70         list_append(ep, &instance->devices[address].endpoints);
     70        list_append(&ep->same_device_eps, &instance->devices[address].endpoints);
    7171        fibril_mutex_unlock(&instance->guard);
    7272}
    … …  
    131131                if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
    132132                        /* endpoint number is < 16, thus first byte is enough */
    133                         instance->devices[target.address].toggle_status[0] &=
    134                             ~(1 << data[4]);
    135                         instance->devices[target.address].toggle_status[1] &=
    136                             ~(1 << data[4]);
     133                        assert(!"NOT IMPLEMENTED!");
     134//                      instance->devices[target.address].toggle_status[0] &=
     135//                          ~(1 << data[4]);
     136//                      instance->devices[target.address].toggle_status[1] &=
     137//                          ~(1 << data[4]);
    137138                }
    138139        break;
    … …  
    142143                /* target must be device */
    143144                if ((data[0] & 0xf) == 0) {
    144                         instance->devices[target.address].toggle_status[0] = 0;
    145                         instance->devices[target.address].toggle_status[1] = 0;
     145                        link_t *current =
     146                            instance->devices[target.address].endpoints.next;
     147                        while (current !=
     148                           instance->devices[target.address].endpoints.prev)
     149                        {
     150                                endpoint_toggle_reset(current);
     151                                current = current->next;
     152                        }
     153//                      instance->devices[target.address].toggle_status[0] = 0;
     154//                      instance->devices[target.address].toggle_status[1] = 0;
    146155                }
    147156        break;
    … …  
    150159}
    151160/*----------------------------------------------------------------------------*/
     161#if 0
    152162/** Get current value of endpoint toggle.
    153163 *
    … …  
    212222        return ret;
    213223}
     224#endif
    214225/*----------------------------------------------------------------------------*/
    215226/** Get a free USB address

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

    r8dc762e0 rf567bcf  
    3535
    3636#include <errno.h>
    37 
    3837#include <usb/host/endpoint.h>
    3938
    … …  
    5756}
    5857/*----------------------------------------------------------------------------*/
     58int endpoint_toggle_get(endpoint_t *instance)
     59{
     60        assert(instance);
     61        return (int)instance->toggle;
     62}
     63/*----------------------------------------------------------------------------*/
     64void endpoint_toggle_set(endpoint_t *instance, int toggle)
     65{
     66        assert(instance);
     67        assert(toggle == 0 || toggle == 1);
     68        instance->toggle = toggle;
     69}
     70/*----------------------------------------------------------------------------*/
    5971void endpoint_toggle_reset(link_t *ep)
    6072{
Note: See TracChangeset for help on using the changeset viewer.