Changeset 41ef5b9 in mainline


Ignore:
Timestamp:
2011-03-21T17:16:10Z (13 years ago)
Author:
Matus Dekanek <smekideki@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4d0c40b
Parents:
fd9f6e4c (diff), 434ef65 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge from usb/development

Files:
6 added
56 edited
7 moved

Legend:

Unmodified
Added
Removed

  • .bzrignore

    rfd9f6e4c r41ef5b9  
    8888./uspace/drv/uhci-hcd/uhci-hcd
    8989./uspace/drv/uhci-rhd/uhci-rhd
     90./uspace/drv/usbflbk/usbflbk
    9091./uspace/drv/usbhub/usbhub
    9192./uspace/drv/usbhid/usbhid

  • boot/arch/amd64/Makefile.inc

    rfd9f6e4c r41ef5b9  
    4747        uhci-hcd \
    4848        uhci-rhd \
     49        usbflbk \
    4950        usbhub \
    5051        usbhid \

  • kernel/tools/genmap.py

    rfd9f6e4c r41ef5b9  
    100100                        for addr, symbol in symbols:
    101101                                value = fname + ':' + symbol
    102                                 data = struct.pack(symtabfmt, addr + offset, value[:MAXSTRING])
     102                                value_bytes = value.encode('ascii')
     103                                data = struct.pack(symtabfmt, addr + offset, value_bytes[:MAXSTRING])
    103104                                out.write(data)
    104105                       
    105         out.write(struct.pack(symtabfmt, 0, ''))
     106        out.write(struct.pack(symtabfmt, 0, b''))
    106107
    107108def main():

  • tools/mkfat.py

    rfd9f6e4c r41ef5b9  
    211211        dir_entry = xstruct.create(DIR_ENTRY)
    212212       
    213         dir_entry.name = mangle_fname(name)
    214         dir_entry.ext = mangle_ext(name)
     213        dir_entry.name = mangle_fname(name).encode('ascii')
     214        dir_entry.ext = mangle_ext(name).encode('ascii')
    215215       
    216216        if (directory):
    … …  
    239239       
    240240        dir_entry.signature = 0x2e
    241         dir_entry.name = '       '
    242         dir_entry.ext = '   '
     241        dir_entry.name = b'       '
     242        dir_entry.ext = b'   '
    243243        dir_entry.attr = 0x10
    244244       
    … …  
    258258       
    259259        dir_entry.signature = [0x2e, 0x2e]
    260         dir_entry.name = '      '
    261         dir_entry.ext = '   '
     260        dir_entry.name = b'      '
     261        dir_entry.ext = b'   '
    262262        dir_entry.attr = 0x10
    263263       

  • tools/mkhord.py

    rfd9f6e4c r41ef5b9  
    8484        payload_size_aligned = align_up(payload_size, align)
    8585       
    86         header.tag = "HORD"
     86        header.tag = b"HORD"
    8787        header.version = 1
    8888        header.encoding = HORD_LSB

  • tools/mktmpfs.py

    rfd9f6e4c r41ef5b9  
    8080                        dentry.kind = TMPFS_FILE
    8181                        dentry.fname_len = len(name)
    82                         dentry.fname = name
     82                        dentry.fname = name.encode('ascii')
    8383                        dentry.flen = size
    8484                       
    … …  
    9797                        dentry.kind = TMPFS_DIRECTORY
    9898                        dentry.fname_len = len(name)
    99                         dentry.fname = name
     99                        dentry.fname = name.encode('ascii')
    100100                       
    101101                        outf.write(dentry.pack())
    … …  
    122122       
    123123        header = xstruct.create(HEADER)
    124         header.tag = "TMPFS"
     124        header.tag = b"TMPFS"
    125125       
    126126        outf.write(header.pack())

  • uspace/Makefile

    rfd9f6e4c r41ef5b9  
    121121                drv/uhci-hcd \
    122122                drv/uhci-rhd \
     123                drv/usbflbk \
    123124                drv/usbhid \
    124125                drv/usbhub \
    … …  
    140141                drv/uhci-hcd \
    141142                drv/uhci-rhd \
     143                drv/usbflbk \
    142144                drv/usbhid \
    143145                drv/usbhub \

  • uspace/app/bdsh/cmds/modules/bdd/bdd.c

    rfd9f6e4c r41ef5b9  
    7070        unsigned int i, j;
    7171        devmap_handle_t handle;
     72        aoff64_t offset;
    7273        uint8_t *blk;
    7374        size_t size, bytes, rows;
    … …  
    120121        }
    121122
     123        offset = ba * block_size;
     124
    122125        while (size > 0) {
    123126                rc = block_read_direct(handle, ba, 1, blk);
    … …  
    133136
    134137                for (j = 0; j < rows; j++) {
     138                        printf("[%06" PRIxOFF64 "] ", offset);
    135139                        for (i = 0; i < BPR; i++) {
    136140                                if (j * BPR + i < bytes)
    … …  
    152156                                }
    153157                        }
     158                        offset += BPR;
    154159                        putchar('\n');
    155160                }

  • uspace/app/usbinfo/dev.c

    rfd9f6e4c r41ef5b9  
    5959        }
    6060
    61         rc = usb_endpoint_pipe_initialize_default_control(&dev->ctrl_pipe,
     61        rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe,
    6262            &dev->wire);
    6363        if (rc != EOK) {
    … …  
    6868        }
    6969
    70         rc = usb_endpoint_pipe_probe_default_control(&dev->ctrl_pipe);
     70        rc = usb_pipe_probe_default_control(&dev->ctrl_pipe);
    7171        if (rc != EOK) {
    7272                fprintf(stderr,
    … …  
    7676        }
    7777
    78         rc = usb_endpoint_pipe_start_session(&dev->ctrl_pipe);
     78        rc = usb_pipe_start_session(&dev->ctrl_pipe);
    7979        if (rc != EOK) {
    8080                fprintf(stderr,
    … …  
    107107
    108108leave:
    109         if (usb_endpoint_pipe_is_session_started(&dev->ctrl_pipe)) {
    110                 usb_endpoint_pipe_end_session(&dev->ctrl_pipe);
     109        if (usb_pipe_is_session_started(&dev->ctrl_pipe)) {
     110                usb_pipe_end_session(&dev->ctrl_pipe);
    111111        }
    112112
    … …  
    118118void destroy_device(usbinfo_device_t *dev)
    119119{
    120         usb_endpoint_pipe_end_session(&dev->ctrl_pipe);
     120        usb_pipe_end_session(&dev->ctrl_pipe);
    121121        free(dev);
    122122}

  • uspace/app/usbinfo/info.c

    rfd9f6e4c r41ef5b9  
    4242#include <usb/classes/classes.h>
    4343#include <usb/classes/hid.h>
     44#include <usb/classes/hub.h>
    4445#include "usbinfo.h"
    4546
    … …  
    109110    usb_standard_device_descriptor_t *descriptor)
    110111{
    111         printf("%sDevice (0x%04x by 0x%04x, %s)\n", prefix,
     112        printf("%sDevice (0x%04x by 0x%04x, %s, %zu configurations)\n", prefix,
    112113            (int) descriptor->product_id,
    113114            (int) descriptor->vendor_id,
    114             usb_str_class(descriptor->device_class));
     115            usb_str_class(descriptor->device_class),
     116            (size_t) descriptor->configuration_count);
    115117}
    116118
    … …  
    118120    usb_standard_configuration_descriptor_t *descriptor)
    119121{
    120         printf("%sConfiguration #%d\n", prefix,
    121             (int) descriptor->configuration_number);
     122        printf("%sConfiguration #%d (%zu interfaces, total %zuB)\n", prefix,
     123            (int) descriptor->configuration_number,
     124            (size_t) descriptor->interface_count,
     125            (size_t) descriptor->total_length);
    122126}
    123127
    … …  
    125129    usb_standard_interface_descriptor_t *descriptor)
    126130{
    127         printf("%sInterface #%d (%s, 0x%02x, 0x%02x)\n", prefix,
     131        printf("%sInterface #%d (%s, 0x%02x, 0x%02x), alternate %d\n", prefix,
    128132            (int) descriptor->interface_number,
    129133            usb_str_class(descriptor->interface_class),
    130134            (int) descriptor->interface_subclass,
    131             (int) descriptor->interface_protocol);
     135            (int) descriptor->interface_protocol,
     136            (int) descriptor->alternate_setting);
    132137}
    133138
    … …  
    153158}
    154159
    155 
    156 static void dump_descriptor_tree_brief_callback(uint8_t *descriptor,
     160static void dump_descriptor_tree_brief_hub(const char *prefix,
     161    usb_hub_descriptor_header_t *descriptor)
     162{
     163        printf("%shub (%d ports)\n", prefix,
     164            (int) descriptor->port_count);
     165}
     166
     167
     168static void dump_descriptor_tree_callback(uint8_t *descriptor,
    157169    size_t depth, void *arg)
    158170{
    … …  
    171183                if (descr_size >= sizeof(descriptor_type)) { \
    172184                        callback(indent, (descriptor_type *) descriptor); \
     185                        if (arg != NULL) { \
     186                                usb_dump_standard_descriptor(stdout, \
     187                                    get_indent(depth +2), "\n", \
     188                                    descriptor, descr_size); \
     189                        } \
    173190                } else { \
    174191                        descr_type = -1; \
    … …  
    191208                    usb_standard_hid_descriptor_t,
    192209                    dump_descriptor_tree_brief_hid);
     210                /*
     211                 * Probably useless, hub descriptor shall not be part of
     212                 * configuration descriptor.
     213                 */
     214                _BRANCH(USB_DESCTYPE_HUB,
     215                    usb_hub_descriptor_header_t,
     216                    dump_descriptor_tree_brief_hub);
    193217
    194218                default:
    … …  
    203227void dump_descriptor_tree_brief(usbinfo_device_t *dev)
    204228{
    205         dump_descriptor_tree_brief_callback((uint8_t *)&dev->device_descriptor,
     229        dump_descriptor_tree_callback((uint8_t *)&dev->device_descriptor,
    206230            (size_t) -1, NULL);
    207231        usb_dp_walk_simple(dev->full_configuration_descriptor,
    208232            dev->full_configuration_descriptor_size,
    209233            usb_dp_standard_descriptor_nesting,
    210             dump_descriptor_tree_brief_callback,
     234            dump_descriptor_tree_callback,
    211235            NULL);
    212236}
     237
     238void dump_descriptor_tree_full(usbinfo_device_t *dev)
     239{
     240        dump_descriptor_tree_callback((uint8_t *)&dev->device_descriptor,
     241            (size_t) -1, dev);
     242        usb_dp_walk_simple(dev->full_configuration_descriptor,
     243            dev->full_configuration_descriptor_size,
     244            usb_dp_standard_descriptor_nesting,
     245            dump_descriptor_tree_callback,
     246            dev);
     247}
     248
    213249
    214250void dump_strings(usbinfo_device_t *dev)

  • uspace/app/usbinfo/main.c

    rfd9f6e4c r41ef5b9  
    134134        _OPTION("-m --match-ids", "Print match ids generated for the device.");
    135135        _OPTION("-t --descriptor-tree", "Print descriptor tree.");
     136        _OPTION("-T --descriptor-tree-full", "Print detailed descriptor tree");
    136137        _OPTION("-s --strings", "Try to print all string descriptors.");
    137138
    … …  
    149150        {"match-ids", no_argument, NULL, 'm'},
    150151        {"descriptor-tree", no_argument, NULL, 't'},
     152        {"descriptor-tree-full", no_argument, NULL, 'T'},
    151153        {"strings", no_argument, NULL, 's'},
    152154        {0, 0, NULL, 0}
    153155};
    154 static const char *short_options = "himts";
     156static const char *short_options = "himtTs";
    155157
    156158static usbinfo_action_t actions[] = {
    … …  
    168170                .opt = 't',
    169171                .action = dump_descriptor_tree_brief,
     172                .active = false
     173        },
     174        {
     175                .opt = 'T',
     176                .action = dump_descriptor_tree_full,
    170177                .active = false
    171178        },

  • uspace/app/usbinfo/usbinfo.h

    rfd9f6e4c r41ef5b9  
    4444
    4545typedef struct {
    46         usb_endpoint_pipe_t ctrl_pipe;
     46        usb_pipe_t ctrl_pipe;
    4747        usb_device_connection_t wire;
    4848        usb_standard_device_descriptor_t device_descriptor;
    … …  
    8282void dump_device_match_ids(usbinfo_device_t *);
    8383void dump_descriptor_tree_brief(usbinfo_device_t *);
     84void dump_descriptor_tree_full(usbinfo_device_t *);
    8485void dump_strings(usbinfo_device_t *);
    8586

  • uspace/doc/doxygroups.h

    rfd9f6e4c r41ef5b9  
    274274         */
    275275
    276 
     276        /**
     277         * @defgroup drvusbfallback USB fallback driver.
     278         * @ingroup usb
     279         * @brief Fallback driver for any USB device.
     280         * @details
     281         * The purpose of this driver is to simplify querying of unknown
     282         * devices from within HelenOS (without a driver, no node at all
     283         * may appear under /dev/devices).
     284         */
     285
     286

  • uspace/drv/ohci/Makefile

    rfd9f6e4c r41ef5b9  
    3333
    3434SOURCES = \
    35         hc_iface.c \
     35        iface.c \
    3636        batch.c \
    3737        main.c \
    38         ohci_hc.c \
    39         ohci_rh.c \
     38        hc.c \
     39        root_hub.c \
    4040        pci.c
    4141

  • uspace/drv/ohci/batch.c

    rfd9f6e4c r41ef5b9  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28 /** @addtogroup drvusbohcihc
     28/** @addtogroup drvusbohci
    2929 * @{
    3030 */
    … …  
    3939
    4040#include "batch.h"
     41#include "utils/malloc32.h"
    4142
    42 static void batch_call_in(batch_t *instance);
    43 static void batch_call_out(batch_t *instance);
    44 static void batch_call_in_and_dispose(batch_t *instance);
    45 static void batch_call_out_and_dispose(batch_t *instance);
     43static void batch_call_in_and_dispose(usb_transfer_batch_t *instance);
     44static void batch_call_out_and_dispose(usb_transfer_batch_t *instance);
    4645
    47 /** Allocate memory and initialize internal data structure.
    48  *
    49  * @param[in] fun DDF function to pass to callback.
    50  * @param[in] target Device and endpoint target of the transaction.
    51  * @param[in] transfer_type Interrupt, Control or Bulk.
    52  * @param[in] max_packet_size maximum allowed size of data packets.
    53  * @param[in] speed Speed of the transaction.
    54  * @param[in] buffer Data source/destination.
    55  * @param[in] size Size of the buffer.
    56  * @param[in] setup_buffer Setup data source (if not NULL)
    57  * @param[in] setup_size Size of setup_buffer (should be always 8)
    58  * @param[in] func_in function to call on inbound transaction completion
    59  * @param[in] func_out function to call on outbound transaction completion
    60  * @param[in] arg additional parameter to func_in or func_out
    61  * @param[in] manager Pointer to toggle management structure.
    62  * @return Valid pointer if all substructures were successfully created,
    63  * NULL otherwise.
    64  *
    65  * Determines the number of needed packets (TDs). Prepares a transport buffer
    66  * (that is accessible by the hardware). Initializes parameters needed for the
    67  * transaction and callback.
    68  */
    69 batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
    70     usb_transfer_type_t transfer_type, size_t max_packet_size,
    71     usb_speed_t speed, char *buffer, size_t size,
    72     char* setup_buffer, size_t setup_size,
     46#define DEFAULT_ERROR_COUNT 3
     47usb_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,
    7357    usbhc_iface_transfer_in_callback_t func_in,
    74     usbhc_iface_transfer_out_callback_t func_out, void *arg
    75     )
     58    usbhc_iface_transfer_out_callback_t func_out,
     59                void *arg,
     60                usb_device_keeper_t *manager
     61                )
    7662{
    77         assert(func_in == NULL || func_out == NULL);
    78         assert(func_in != NULL || func_out != NULL);
     63#define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
     64        if (ptr == NULL) { \
     65                usb_log_error(message); \
     66                if (instance) { \
     67                        batch_dispose(instance); \
     68                } \
     69                return NULL; \
     70        } else (void)0
    7971
    80 #define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
    81         if (ptr == NULL) { \
    82                 usb_log_error(message); \
    83                 if (instance) { \
    84                         batch_dispose(instance); \
    85                 } \
    86                 return NULL; \
    87         } else (void)0
    88 
    89         batch_t *instance = malloc(sizeof(batch_t));
     72        usb_transfer_batch_t *instance = malloc(sizeof(usb_transfer_batch_t));
    9073        CHECK_NULL_DISPOSE_RETURN(instance,
    9174            "Failed to allocate batch instance.\n");
    92         bzero(instance, sizeof(batch_t));
     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);
    9378
    94         if (size > 0) {
    95                 /* TODO: use device accessible malloc here */
    96                 instance->transport_buffer = malloc(size);
    97                 CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
    98                     "Failed to allocate device accessible buffer.\n");
    99         }
     79        if (buffer_size > 0) {
     80                instance->transport_buffer = malloc32(buffer_size);
     81                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
     82                    "Failed to allocate device accessible buffer.\n");
     83        }
    10084
    101         if (setup_size > 0) {
    102                 /* TODO: use device accessible malloc here */
    103                 instance->setup_buffer = malloc(setup_size);
    104                 CHECK_NULL_DISPOSE_RETURN(instance->setup_buffer,
    105                     "Failed to allocate device accessible setup buffer.\n");
    106                 memcpy(instance->setup_buffer, setup_buffer, setup_size);
    107         }
     85        if (setup_size > 0) {
     86                instance->setup_buffer = malloc32(setup_size);
     87                CHECK_NULL_DISPOSE_RETURN(instance->setup_buffer,
     88                    "Failed to allocate device accessible setup buffer.\n");
     89                memcpy(instance->setup_buffer, setup_buffer, setup_size);
     90        }
    10891
    109         link_initialize(&instance->link);
    11092
    111         instance->max_packet_size = max_packet_size;
    112         instance->target = target;
    113         instance->transfer_type = transfer_type;
    114         instance->buffer = buffer;
    115         instance->buffer_size = size;
    116         instance->setup_size = setup_size;
    117         instance->fun = fun;
    118         instance->arg = arg;
    119         instance->speed = speed;
    120         instance->callback_out = func_out;
    121         instance->callback_in = func_in;
    122 
    123         usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
    124             instance, target.address, target.endpoint);
    12593        return instance;
    12694}
    12795/*----------------------------------------------------------------------------*/
    128 /** Mark batch as finished and continue with next step.
    129  *
    130  * @param[in] instance Batch structure to use.
    131  *
    132  */
    133 void batch_finish(batch_t *instance, int error)
     96void batch_dispose(usb_transfer_batch_t *instance)
    13497{
    13598        assert(instance);
    136         instance->error = error;
    137         instance->next_step(instance);
     99        free32(instance->transport_buffer);
     100        free32(instance->setup_buffer);
     101        free(instance);
    138102}
    139103/*----------------------------------------------------------------------------*/
    140 /** Check batch TDs for activity.
    141  *
    142  * @param[in] instance Batch structure to use.
    143  * @return False, if there is an active TD, true otherwise.
    144  *
    145  * Walk all TDs. Stop with false if there is an active one (it is to be
    146  * processed). Stop with true if an error is found. Return true if the last TS
    147  * is reached.
    148  */
    149 bool batch_is_complete(batch_t *instance)
    150 {
    151         assert(instance);
    152         /* TODO: implement */
    153         return true;
    154 }
    155 /*----------------------------------------------------------------------------*/
    156 /** Prepares control write transaction.
    157  *
    158  * @param[in] instance Batch structure to use.
    159  *
    160  * Uses genercir control function with pids OUT and IN.
    161  */
    162 void batch_control_write(batch_t *instance)
     104void batch_control_write(usb_transfer_batch_t *instance)
    163105{
    164106        assert(instance);
    … …  
    171113}
    172114/*----------------------------------------------------------------------------*/
    173 /** Prepares control read transaction.
    174  *
    175  * @param[in] instance Batch structure to use.
    176  *
    177  * Uses generic control with pids IN and OUT.
    178  */
    179 void batch_control_read(batch_t *instance)
     115void batch_control_read(usb_transfer_batch_t *instance)
    180116{
    181117        assert(instance);
    182118        instance->next_step = batch_call_in_and_dispose;
    183119        /* TODO: implement */
    184         usb_log_debug("Batch(%p) CONTROL READ initialized.\n", instance);
     120        usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
    185121}
    186122/*----------------------------------------------------------------------------*/
    187 /** Prepare interrupt in transaction.
    188  *
    189  * @param[in] instance Batch structure to use.
    190  *
    191  * Data transaction with PID_IN.
    192  */
    193 void batch_interrupt_in(batch_t *instance)
     123void batch_interrupt_in(usb_transfer_batch_t *instance)
    194124{
    195125        assert(instance);
     126        instance->direction = USB_DIRECTION_IN;
     127        instance->next_step = batch_call_in_and_dispose;
    196128        /* TODO: implement */
    197         instance->next_step = batch_call_in_and_dispose;
    198129        usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
    199130}
    200131/*----------------------------------------------------------------------------*/
    201 /** Prepare interrupt out transaction.
    202  *
    203  * @param[in] instance Batch structure to use.
    204  *
    205  * Data transaction with PID_OUT.
    206  */
    207 void batch_interrupt_out(batch_t *instance)
     132void batch_interrupt_out(usb_transfer_batch_t *instance)
    208133{
    209134        assert(instance);
     135        instance->direction = USB_DIRECTION_OUT;
    210136        /* We are data out, we are supposed to provide data */
    211137        memcpy(instance->transport_buffer, instance->buffer,
    … …  
    216142}
    217143/*----------------------------------------------------------------------------*/
    218 /** Prepare bulk in transaction.
    219  *
    220  * @param[in] instance Batch structure to use.
    221  *
    222  * Data transaction with PID_IN.
    223  */
    224 void batch_bulk_in(batch_t *instance)
     144void batch_bulk_in(usb_transfer_batch_t *instance)
    225145{
    226146        assert(instance);
     147        instance->direction = USB_DIRECTION_IN;
    227148        instance->next_step = batch_call_in_and_dispose;
    228149        /* TODO: implement */
    … …  
    230151}
    231152/*----------------------------------------------------------------------------*/
    232 /** Prepare bulk out transaction.
    233  *
    234  * @param[in] instance Batch structure to use.
    235  *
    236  * Data transaction with PID_OUT.
    237  */
    238 void batch_bulk_out(batch_t *instance)
     153void batch_bulk_out(usb_transfer_batch_t *instance)
    239154{
    240155        assert(instance);
    241         /* We are data out, we are supposed to provide data */
    242         memcpy(instance->transport_buffer, instance->buffer,
    243             instance->buffer_size);
    244         instance->next_step = batch_call_out_and_dispose;
     156        instance->direction = USB_DIRECTION_IN;
     157        instance->next_step = batch_call_in_and_dispose;
    245158        /* TODO: implement */
    246         usb_log_debug("Batch(%p) BULK OUT initialized.\n", instance);
    247 }
    248 /*----------------------------------------------------------------------------*/
    249 /** Prepare data, get error status and call callback in.
    250  *
    251  * @param[in] instance Batch structure to use.
    252  * Copies data from transport buffer, and calls callback with appropriate
    253  * parameters.
    254  */
    255 void batch_call_in(batch_t *instance)
    256 {
    257         assert(instance);
    258         assert(instance->callback_in);
    259 
    260         /* We are data in, we need data */
    261         memcpy(instance->buffer, instance->transport_buffer,
    262             instance->buffer_size);
    263 
    264         int err = instance->error;
    265         usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
    266             instance, instance->transfer_type, str_error(err), err,
    267             instance->transfered_size);
    268 
    269         instance->callback_in(
    270             instance->fun, err, instance->transfered_size, instance->arg);
    271 }
    272 /*----------------------------------------------------------------------------*/
    273 /** Get error status and call callback out.
    274  *
    275  * @param[in] instance Batch structure to use.
    276  */
    277 void batch_call_out(batch_t *instance)
    278 {
    279         assert(instance);
    280         assert(instance->callback_out);
    281 
    282         int err = instance->error;
    283         usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n",
    284             instance, instance->transfer_type, str_error(err), err);
    285         instance->callback_out(instance->fun,
    286             err, instance->arg);
     159        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
    287160}
    288161/*----------------------------------------------------------------------------*/
    … …  
    291164 * @param[in] instance Batch structure to use.
    292165 */
    293 void batch_call_in_and_dispose(batch_t *instance)
     166void batch_call_in_and_dispose(usb_transfer_batch_t *instance)
    294167{
    295168        assert(instance);
    296         batch_call_in(instance);
     169        usb_transfer_batch_call_in(instance);
    297170        batch_dispose(instance);
    298171}
    … …  
    302175 * @param[in] instance Batch structure to use.
    303176 */
    304 void batch_call_out_and_dispose(batch_t *instance)
     177void batch_call_out_and_dispose(usb_transfer_batch_t *instance)
    305178{
    306179        assert(instance);
    307         batch_call_out(instance);
     180        usb_transfer_batch_call_out(instance);
    308181        batch_dispose(instance);
    309 }
    310 /*----------------------------------------------------------------------------*/
    311 /** Correctly dispose all used data structures.
    312  *
    313  * @param[in] instance Batch structure to use.
    314  */
    315 void batch_dispose(batch_t *instance)
    316 {
    317         assert(instance);
    318         usb_log_debug("Batch(%p) disposing.\n", instance);
    319         if (instance->setup_buffer)
    320                 free(instance->setup_buffer);
    321         if (instance->transport_buffer)
    322                 free(instance->transport_buffer);
    323         free(instance);
    324182}
    325183/**

  • uspace/drv/ohci/batch.h

    rfd9f6e4c r41ef5b9  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28 /** @addtogroup drvusbuhcihc
     28/** @addtogroup drvusbohci
    2929 * @{
    3030 */
    3131/** @file
    32  * @brief UHCI driver USB transaction structure
     32 * @brief OHCI driver USB transaction structure
    3333 */
    34 #ifndef DRV_UHCI_BATCH_H
    35 #define DRV_UHCI_BATCH_H
     34#ifndef DRV_OHCI_BATCH_H
     35#define DRV_OHCI_BATCH_H
    3636
    37 #include <adt/list.h>
    3837
    3938#include <usbhc_iface.h>
    4039#include <usb/usb.h>
     40#include <usb/host/device_keeper.h>
     41#include <usb/host/batch.h>
    4142
    42 typedef struct batch
    43 {
    44         link_t link;
    45         usb_speed_t speed;
    46         usb_target_t target;
    47         usb_transfer_type_t transfer_type;
    48         usbhc_iface_transfer_in_callback_t callback_in;
    49         usbhc_iface_transfer_out_callback_t callback_out;
    50         void *arg;
    51         char *transport_buffer;
    52         char *setup_buffer;
    53         size_t setup_size;
    54         char *buffer;
    55         size_t buffer_size;
    56         size_t max_packet_size;
    57         size_t packets;
    58         size_t transfered_size;
    59         int error;
    60         ddf_fun_t *fun;
    61         void (*next_step)(struct batch*);
    62 } batch_t;
    63 
    64 batch_t * batch_get(
     43usb_transfer_batch_t * batch_get(
    6544    ddf_fun_t *fun,
    6645                usb_target_t target,
    … …  
    7453    usbhc_iface_transfer_in_callback_t func_in,
    7554    usbhc_iface_transfer_out_callback_t func_out,
    76                 void *arg
     55                void *arg,
     56                usb_device_keeper_t *manager
    7757                );
    7858
    79 void batch_dispose(batch_t *instance);
     59void batch_dispose(usb_transfer_batch_t *instance);
    8060
    81 void batch_finish(batch_t *instance, int error);
     61void batch_control_write(usb_transfer_batch_t *instance);
    8262
    83 bool batch_is_complete(batch_t *instance);
     63void batch_control_read(usb_transfer_batch_t *instance);
    8464
    85 void batch_control_write(batch_t *instance);
     65void batch_interrupt_in(usb_transfer_batch_t *instance);
    8666
    87 void batch_control_read(batch_t *instance);
     67void batch_interrupt_out(usb_transfer_batch_t *instance);
    8868
    89 void batch_interrupt_in(batch_t *instance);
     69void batch_bulk_in(usb_transfer_batch_t *instance);
    9070
    91 void batch_interrupt_out(batch_t *instance);
    92 
    93 void batch_bulk_in(batch_t *instance);
    94 
    95 void batch_bulk_out(batch_t *instance);
     71void batch_bulk_out(usb_transfer_batch_t *instance);
    9672#endif
    9773/**

  • uspace/drv/ohci/hc.h

    rfd9f6e4c r41ef5b9  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28 
    29 /** @addtogroup drvusbohcihc
     28/** @addtogroup drvusbohci
    3029 * @{
    3130 */
    … …  
    3332 * @brief OHCI host controller driver structure
    3433 */
    35 #ifndef DRV_OHCI_OHCI_HC_H
    36 #define DRV_OHCI_OHCI_HC_H
     34#ifndef DRV_OHCI_HC_H
     35#define DRV_OHCI_HC_H
    3736
    3837#include <fibril.h>
    … …  
    4241
    4342#include <usb/usb.h>
     43#include <usb/host/device_keeper.h>
    4444#include <usbhc_iface.h>
    4545
    4646#include "batch.h"
    4747#include "ohci_regs.h"
    48 #include "ohci_rh.h"
     48#include "root_hub.h"
    4949
    50 typedef struct ohci_hc {
     50typedef struct hc {
    5151        ohci_regs_t *registers;
    5252        usb_address_t rh_address;
    53         ohci_rh_t rh;
     53        rh_t rh;
    5454        ddf_fun_t *ddf_instance;
    55 } ohci_hc_t;
     55        usb_device_keeper_t manager;
     56        fid_t interrupt_emulator;
     57} hc_t;
    5658
    57 int ohci_hc_init(ohci_hc_t *instance, ddf_fun_t *fun,
     59int hc_init(hc_t *instance, ddf_fun_t *fun, ddf_dev_t *dev,
    5860     uintptr_t regs, size_t reg_size, bool interrupts);
    5961
    60 int ohci_hc_schedule(ohci_hc_t *instance, batch_t *batch);
     62int hc_register_hub(hc_t *instance);
    6163
    62 void ohci_hc_interrupt(ohci_hc_t *instance, uint16_t status);
     64int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch);
     65
     66void hc_interrupt(hc_t *instance, uint32_t status);
    6367
    6468/** Safely dispose host controller internal structures
    … …  
    6670 * @param[in] instance Host controller structure to use.
    6771 */
    68 static inline void ohci_hc_fini(ohci_hc_t *instance) { /* TODO: implement*/ };
     72static inline void hc_fini(hc_t *instance) { /* TODO: implement*/ };
    6973
    7074/** Get and cast pointer to the driver data
    … …  
    7377 * @return cast pointer to driver_data
    7478 */
    75 static inline ohci_hc_t * fun_to_ohci_hc(ddf_fun_t *fun)
    76         { return (ohci_hc_t*)fun->driver_data; }
     79static inline hc_t * fun_to_hc(ddf_fun_t *fun)
     80        { return (hc_t*)fun->driver_data; }
    7781#endif
    7882/**

  • uspace/drv/ohci/iface.c

    rfd9f6e4c r41ef5b9  
    4343
    4444#include "iface.h"
     45#include "hc.h"
    4546
    4647#define UNSUPPORTED(methodname) \
    … …  
    5960static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
    6061{
    61         UNSUPPORTED("reserve_default_address");
    62 
    63         return ENOTSUP;
    64 }
    65 
     62  assert(fun);
     63  hc_t *hc = fun_to_hc(fun);
     64  assert(hc);
     65  usb_log_debug("Default address request with speed %d.\n", speed);
     66  usb_device_keeper_reserve_default_address(&hc->manager, speed);
     67  return EOK;
     68}
     69/*----------------------------------------------------------------------------*/
    6670/** Release default address.
    6771 *
    … …  
    7175static int release_default_address(ddf_fun_t *fun)
    7276{
    73         UNSUPPORTED("release_default_address");
    74 
    75         return ENOTSUP;
    76 }
    77 
     77  assert(fun);
     78  hc_t *hc = fun_to_hc(fun);
     79  assert(hc);
     80  usb_log_debug("Default address release.\n");
     81  usb_device_keeper_release_default_address(&hc->manager);
     82  return EOK;
     83}
     84/*----------------------------------------------------------------------------*/
    7885/** Found free USB address.
    7986 *
    … …  
    8693    usb_address_t *address)
    8794{
    88         UNSUPPORTED("request_address");
    89 
    90         return ENOTSUP;
    91 }
    92 
     95  assert(fun);
     96  hc_t *hc = fun_to_hc(fun);
     97  assert(hc);
     98  assert(address);
     99
     100  usb_log_debug("Address request with speed %d.\n", speed);
     101  *address = device_keeper_get_free_address(&hc->manager, speed);
     102  usb_log_debug("Address request with result: %d.\n", *address);
     103  if (*address <= 0)
     104    return *address;
     105  return EOK;
     106}
     107/*----------------------------------------------------------------------------*/
    93108/** Bind USB address with device devman handle.
    94109 *
    … …  
    101116    usb_address_t address, devman_handle_t handle)
    102117{
    103         UNSUPPORTED("bind_address");
    104 
    105         return ENOTSUP;
    106 }
    107 
     118  assert(fun);
     119  hc_t *hc = fun_to_hc(fun);
     120  assert(hc);
     121  usb_log_debug("Address bind %d-%d.\n", address, handle);
     122  usb_device_keeper_bind(&hc->manager, address, handle);
     123  return EOK;
     124}
     125/*----------------------------------------------------------------------------*/
    108126/** Release previously requested address.
    109127 *
    … …  
    114132static int release_address(ddf_fun_t *fun, usb_address_t address)
    115133{
    116         UNSUPPORTED("release_address");
    117 
    118         return ENOTSUP;
     134  assert(fun);
     135  hc_t *hc = fun_to_hc(fun);
     136  assert(hc);
     137  usb_log_debug("Address release %d.\n", address);
     138  usb_device_keeper_release(&hc->manager, address);
     139  return EOK;
    119140}
    120141
    … …  
    155176        return ENOTSUP;
    156177}
    157 
     178/*----------------------------------------------------------------------------*/
    158179/** Schedule interrupt out transfer.
    159180 *
    … …  
    177198    usbhc_iface_transfer_out_callback_t callback, void *arg)
    178199{
    179         UNSUPPORTED("interrupt_out");
    180 
    181         return ENOTSUP;
    182 }
    183 
     200  hc_t *hc = fun_to_hc(fun);
     201  assert(hc);
     202  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     203
     204  usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
     205      target.address, target.endpoint, size, max_packet_size);
     206
     207  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     208      max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
     209      &hc->manager);
     210  if (!batch)
     211    return ENOMEM;
     212  batch_interrupt_out(batch);
     213  const int ret = hc_schedule(hc, batch);
     214  if (ret != EOK) {
     215    batch_dispose(batch);
     216    return ret;
     217  }
     218  return EOK;
     219}
     220/*----------------------------------------------------------------------------*/
    184221/** Schedule interrupt in transfer.
    185222 *
    … …  
    203240    usbhc_iface_transfer_in_callback_t callback, void *arg)
    204241{
    205         UNSUPPORTED("interrupt_in");
    206 
    207         return ENOTSUP;
    208 }
    209 
     242  assert(fun);
     243  hc_t *hc = fun_to_hc(fun);
     244  assert(hc);
     245  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     246  usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
     247      target.address, target.endpoint, size, max_packet_size);
     248
     249  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     250      max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
     251      &hc->manager);
     252  if (!batch)
     253    return ENOMEM;
     254  batch_interrupt_in(batch);
     255  const int ret = hc_schedule(hc, batch);
     256  if (ret != EOK) {
     257    batch_dispose(batch);
     258    return ret;
     259  }
     260  return EOK;
     261}
     262/*----------------------------------------------------------------------------*/
    210263/** Schedule bulk out transfer.
    211264 *
    … …  
    229282    usbhc_iface_transfer_out_callback_t callback, void *arg)
    230283{
    231         UNSUPPORTED("bulk_out");
    232 
    233         return ENOTSUP;
    234 }
    235 
     284  assert(fun);
     285  hc_t *hc = fun_to_hc(fun);
     286  assert(hc);
     287  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     288
     289  usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
     290      target.address, target.endpoint, size, max_packet_size);
     291
     292  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     293      max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
     294      &hc->manager);
     295  if (!batch)
     296    return ENOMEM;
     297  batch_bulk_out(batch);
     298  const int ret = hc_schedule(hc, batch);
     299  if (ret != EOK) {
     300    batch_dispose(batch);
     301    return ret;
     302  }
     303  return EOK;
     304
     305}
     306/*----------------------------------------------------------------------------*/
    236307/** Schedule bulk in transfer.
    237308 *
    … …  
    255326    usbhc_iface_transfer_in_callback_t callback, void *arg)
    256327{
    257         UNSUPPORTED("bulk_in");
    258 
    259         return ENOTSUP;
    260 }
    261 
     328  assert(fun);
     329  hc_t *hc = fun_to_hc(fun);
     330  assert(hc);
     331  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     332  usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
     333      target.address, target.endpoint, size, max_packet_size);
     334
     335  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     336      max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
     337      &hc->manager);
     338  if (!batch)
     339    return ENOMEM;
     340  batch_bulk_in(batch);
     341  const int ret = hc_schedule(hc, batch);
     342  if (ret != EOK) {
     343    batch_dispose(batch);
     344    return ret;
     345  }
     346  return EOK;
     347}
     348/*----------------------------------------------------------------------------*/
    262349/** Schedule control write transfer.
    263350 *
    … …  
    282369static int control_write(ddf_fun_t *fun, usb_target_t target,
    283370    size_t max_packet_size,
    284     void *setup_packet, size_t setup_packet_size,
    285     void *data_buffer, size_t data_buffer_size,
     371    void *setup_data, size_t setup_size,
     372    void *data, size_t size,
    286373    usbhc_iface_transfer_out_callback_t callback, void *arg)
    287374{
    288         UNSUPPORTED("control_write");
    289 
    290         return ENOTSUP;
    291 }
    292 
     375  assert(fun);
     376  hc_t *hc = fun_to_hc(fun);
     377  assert(hc);
     378  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     379  usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
     380      speed, target.address, target.endpoint, size, max_packet_size);
     381
     382  if (setup_size != 8)
     383    return EINVAL;
     384
     385  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     386      max_packet_size, speed, data, size, setup_data, setup_size,
     387      NULL, callback, arg, &hc->manager);
     388  if (!batch)
     389    return ENOMEM;
     390  usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
     391  batch_control_write(batch);
     392  const int ret = hc_schedule(hc, batch);
     393  if (ret != EOK) {
     394    batch_dispose(batch);
     395    return ret;
     396  }
     397  return EOK;
     398}
     399/*----------------------------------------------------------------------------*/
    293400/** Schedule control read transfer.
    294401 *
    … …  
    313420static int control_read(ddf_fun_t *fun, usb_target_t target,
    314421    size_t max_packet_size,
    315     void *setup_packet, size_t setup_packet_size,
    316     void *data_buffer, size_t data_buffer_size,
     422    void *setup_data, size_t setup_size,
     423    void *data, size_t size,
    317424    usbhc_iface_transfer_in_callback_t callback, void *arg)
    318425{
    319         UNSUPPORTED("control_read");
    320 
    321         return ENOTSUP;
    322 }
    323 
    324 /** Host controller interface implementation for EHCI. */
    325 usbhc_iface_t ohci_hc_iface = {
     426  assert(fun);
     427  hc_t *hc = fun_to_hc(fun);
     428  assert(hc);
     429  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     430
     431  usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
     432      speed, target.address, target.endpoint, size, max_packet_size);
     433  usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     434      max_packet_size, speed, data, size, setup_data, setup_size, callback,
     435      NULL, arg, &hc->manager);
     436  if (!batch)
     437    return ENOMEM;
     438  batch_control_read(batch);
     439  const int ret = hc_schedule(hc, batch);
     440  if (ret != EOK) {
     441    batch_dispose(batch);
     442    return ret;
     443  }
     444  return EOK;
     445}
     446/*----------------------------------------------------------------------------*/
     447/** Host controller interface implementation for OHCI. */
     448usbhc_iface_t hc_iface = {
    326449        .reserve_default_address = reserve_default_address,
    327450        .release_default_address = release_default_address,

  • uspace/drv/ohci/iface.h

    rfd9f6e4c r41ef5b9  
    4040#define NAME "ohci"
    4141
    42 extern usbhc_iface_t ohci_hc_iface;
     42extern usbhc_iface_t hc_iface;
    4343
    4444#endif

  • uspace/drv/ohci/main.c

    rfd9f6e4c r41ef5b9  
    4545#include "pci.h"
    4646#include "iface.h"
    47 #include "ohci_hc.h"
     47#include "hc.h"
    4848
    4949static int ohci_add_device(ddf_dev_t *device);
     50static int get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
     51{
     52        assert(handle);
     53  assert(fun != NULL);
     54
     55  *handle = fun->handle;
     56  return EOK;
     57}
     58/*----------------------------------------------------------------------------*/
     59static int get_address(
     60    ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
     61{
     62        assert(fun);
     63        usb_device_keeper_t *manager = &fun_to_hc(fun)->manager;
     64  usb_address_t addr = usb_device_keeper_find(manager, handle);
     65  if (addr < 0) {
     66    return addr;
     67  }
     68
     69  if (address != NULL) {
     70    *address = addr;
     71  }
     72
     73  return EOK;
     74}
    5075/*----------------------------------------------------------------------------*/
    5176/** IRQ handling callback, identifies device
    … …  
    5883{
    5984        assert(dev);
    60         ohci_hc_t *hc = (ohci_hc_t*)dev->driver_data;
     85        hc_t *hc = (hc_t*)dev->driver_data;
    6186        assert(hc);
    62         ohci_hc_interrupt(hc, 0);
     87        hc_interrupt(hc, 0);
    6388}
    6489/*----------------------------------------------------------------------------*/
    … …  
    7196        .driver_ops = &ohci_driver_ops
    7297};
     98/*----------------------------------------------------------------------------*/
     99static usb_iface_t hc_usb_iface = {
     100        .get_address = get_address,
     101        .get_hc_handle = get_hc_handle,
     102};
     103/*----------------------------------------------------------------------------*/
    73104static ddf_dev_ops_t hc_ops = {
    74         .interfaces[USBHC_DEV_IFACE] = &ohci_hc_iface,
    75 };
    76 
     105        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
     106        .interfaces[USBHC_DEV_IFACE] = &hc_iface,
     107};
    77108/*----------------------------------------------------------------------------*/
    78109/** Initializes a new ddf driver instance of OHCI hcd.
    … …  
    105136            "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));
    106137
    107         ohci_hc_t *hcd = malloc(sizeof(ohci_hc_t));
     138        hc_t *hcd = malloc(sizeof(hc_t));
    108139        if (hcd == NULL) {
    109140                usb_log_error("Failed to allocate OHCI driver.\n");
    … …  
    129160        }
    130161
    131         ret = ohci_hc_init(hcd, hc_fun, mem_reg_base, mem_reg_size, interrupts);
     162        ret = hc_init(hcd, hc_fun, device, mem_reg_base, mem_reg_size, interrupts);
    132163        if (ret != EOK) {
    133164                usb_log_error("Failed to initialize OHCI driver.\n");
    … …  
    148179        hc_fun->driver_data = hcd;
    149180
    150         /* TODO: register interrupt handler */
     181        fid_t later = fibril_create((int(*)(void*))hc_register_hub, hcd);
     182        fibril_add_ready(later);
    151183
    152184        usb_log_info("Controlling new OHCI device `%s' (handle %llu).\n",

  • uspace/drv/ohci/ohci_regs.h

    rfd9f6e4c r41ef5b9  
    4343        volatile uint32_t command_status;
    4444        volatile uint32_t interrupt_status;
     45#define IS_SO (1 << 0)
     46#define IS_WDH (1 << 1)
     47#define IS_SF (1 << 2)
     48#define IS_RD (1 << 3)
     49#define IS_UE (1 << 4)
     50#define IS_FNO (1 << 5)
     51#define IS_RHSC (1 << 6)
     52#define IS_OC (1 << 30)
    4553        volatile uint32_t interupt_enable;
    4654#define IE_SO   (1 << 0)

  • uspace/drv/ohci/root_hub.c

    rfd9f6e4c r41ef5b9  
    3030 */
    3131/** @file
    32  * @brief UHCI driver
     32 * @brief OHCI driver
    3333 */
    3434#include <assert.h>
    … …  
    3838#include <usb/debug.h>
    3939
    40 #include "ohci_rh.h"
     40#include "root_hub.h"
    4141
    4242/** Root hub initialization
    4343 * @return Error code.
    4444 */
    45 int ohci_rh_init(ohci_rh_t *instance, ohci_regs_t *regs)
     45int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs)
    4646{
    4747        assert(instance);
    48         instance->address = 0;
     48        instance->address = -1;
    4949        instance->registers = regs;
     50        instance->device = dev;
    5051
    5152        usb_log_info("OHCI root hub with %d ports.\n", regs->rh_desc_a & 0xff);
    … …  
    5556}
    5657/*----------------------------------------------------------------------------*/
    57 void ohci_rh_request(ohci_rh_t *instance, batch_t *request)
     58int rh_request(rh_t *instance, usb_transfer_batch_t *request)
    5859{
     60        assert(instance);
     61        assert(request);
    5962        /* TODO: implement */
     63        if (request->setup_buffer) {
     64                usb_log_info("Root hub got SETUP packet: %s.\n",
     65                    usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
     66        }
     67        usb_log_error("Root hub request processing not implemented.\n");
     68        usb_transfer_batch_finish(request, ENOTSUP);
     69        return EOK;
    6070}
    6171/*----------------------------------------------------------------------------*/
    62 void ohci_rh_interrupt(ohci_rh_t *instance)
     72void rh_interrupt(rh_t *instance)
    6373{
    64         usb_log_info("Interrupt!!.\n");
     74        usb_log_error("Root hub interrupt not implemented.\n");
    6575        /* TODO: implement */
    6676}

  • uspace/drv/ohci/root_hub.h

    rfd9f6e4c r41ef5b9  
    3333 * @brief OHCI driver
    3434 */
    35 #ifndef DRV_OHCI_OHCI_RH_H
    36 #define DRV_OHCI_OHCI_RH_H
     35#ifndef DRV_OHCI_ROOT_HUB_H
     36#define DRV_OHCI_ROOT_HUB_H
    3737
    3838#include <usb/usb.h>
    … …  
    4141#include "batch.h"
    4242
    43 typedef struct ohci_rh {
     43typedef struct rh {
    4444        ohci_regs_t *registers;
    4545        usb_address_t address;
    46 } ohci_rh_t;
     46        ddf_dev_t *device;
     47} rh_t;
    4748
    48 int ohci_rh_init(ohci_rh_t *instance, ohci_regs_t *regs);
     49int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs);
    4950
    50 void ohci_rh_request(ohci_rh_t *instance, batch_t *request);
     51int rh_request(rh_t *instance, usb_transfer_batch_t *request);
    5152
    52 void ohci_rh_interrupt(ohci_rh_t *instance);
     53void rh_interrupt(rh_t *instance);
    5354#endif
    5455/**

  • uspace/drv/uhci-hcd/Makefile

    rfd9f6e4c r41ef5b9  
    4040        uhci_rh.c \
    4141        uhci_struct/transfer_descriptor.c \
    42         utils/device_keeper.c \
    4342        pci.c \
    4443        batch.c

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

    rfd9f6e4c r41ef5b9  
    4242#include "uhci_hc.h"
    4343#include "utils/malloc32.h"
     44#include "uhci_struct/transfer_descriptor.h"
    4445
    4546#define DEFAULT_ERROR_COUNT 3
    4647
    47 static void batch_control(batch_t *instance,
     48typedef struct uhci_batch {
     49        qh_t *qh;
     50        td_t *tds;
     51        size_t packets;
     52        usb_device_keeper_t *manager;
     53} uhci_batch_t;
     54
     55static void batch_control(usb_transfer_batch_t *instance,
    4856    usb_packet_id data_stage, usb_packet_id status_stage);
    49 static void batch_data(batch_t *instance, usb_packet_id pid);
    50 static void batch_call_in(batch_t *instance);
    51 static void batch_call_out(batch_t *instance);
    52 static void batch_call_in_and_dispose(batch_t *instance);
    53 static void batch_call_out_and_dispose(batch_t *instance);
     57static void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid);
     58static void batch_call_in_and_dispose(usb_transfer_batch_t *instance);
     59static void batch_call_out_and_dispose(usb_transfer_batch_t *instance);
    5460
    5561
    … …  
    7682 * transaction and callback.
    7783 */
    78 batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
     84usb_transfer_batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
    7985    usb_transfer_type_t transfer_type, size_t max_packet_size,
    80     usb_speed_t speed, char *buffer, size_t size,
     86    usb_speed_t speed, char *buffer, size_t buffer_size,
    8187    char* setup_buffer, size_t setup_size,
    8288    usbhc_iface_transfer_in_callback_t func_in,
    8389    usbhc_iface_transfer_out_callback_t func_out, void *arg,
    84     device_keeper_t *manager
     90    usb_device_keeper_t *manager
    8591    )
    8692{
    … …  
    97103        } else (void)0
    98104
    99         batch_t *instance = malloc(sizeof(batch_t));
     105        usb_transfer_batch_t *instance = malloc(sizeof(usb_transfer_batch_t));
    100106        CHECK_NULL_DISPOSE_RETURN(instance,
    101107            "Failed to allocate batch instance.\n");
    102         bzero(instance, sizeof(batch_t));
    103 
    104         instance->qh = malloc32(sizeof(qh_t));
    105         CHECK_NULL_DISPOSE_RETURN(instance->qh,
     108        usb_transfer_batch_init(instance, target, transfer_type, speed, max_packet_size,
     109            buffer, NULL, buffer_size, NULL, setup_size, func_in,
     110            func_out, arg, fun, NULL);
     111
     112
     113        uhci_batch_t *data = malloc(sizeof(uhci_batch_t));
     114        CHECK_NULL_DISPOSE_RETURN(instance,
     115            "Failed to allocate batch instance.\n");
     116        bzero(data, sizeof(uhci_batch_t));
     117        data->manager = manager;
     118        instance->private_data = data;
     119
     120        data->packets = (buffer_size + max_packet_size - 1) / max_packet_size;
     121        if (transfer_type == USB_TRANSFER_CONTROL) {
     122                data->packets += 2;
     123        }
     124
     125        data->tds = malloc32(sizeof(td_t) * data->packets);
     126        CHECK_NULL_DISPOSE_RETURN(
     127            data->tds, "Failed to allocate transfer descriptors.\n");
     128        bzero(data->tds, sizeof(td_t) * data->packets);
     129
     130        data->qh = malloc32(sizeof(qh_t));
     131        CHECK_NULL_DISPOSE_RETURN(data->qh,
    106132            "Failed to allocate batch queue head.\n");
    107         qh_init(instance->qh);
    108 
    109         instance->packets = (size + max_packet_size - 1) / max_packet_size;
    110         if (transfer_type == USB_TRANSFER_CONTROL) {
    111                 instance->packets += 2;
    112         }
    113 
    114         instance->tds = malloc32(sizeof(td_t) * instance->packets);
    115         CHECK_NULL_DISPOSE_RETURN(
    116             instance->tds, "Failed to allocate transfer descriptors.\n");
    117         bzero(instance->tds, sizeof(td_t) * instance->packets);
    118 
    119         if (size > 0) {
    120                 instance->transport_buffer = malloc32(size);
     133        qh_init(data->qh);
     134        qh_set_element_td(data->qh, addr_to_phys(data->tds));
     135
     136        if (buffer_size > 0) {
     137                instance->transport_buffer = malloc32(buffer_size);
    121138                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
    122139                    "Failed to allocate device accessible buffer.\n");
    … …  
    130147        }
    131148
    132 
    133         link_initialize(&instance->link);
    134 
    135         instance->max_packet_size = max_packet_size;
    136         instance->target = target;
    137         instance->transfer_type = transfer_type;
    138         instance->buffer = buffer;
    139         instance->buffer_size = size;
    140         instance->setup_size = setup_size;
    141         instance->fun = fun;
    142         instance->arg = arg;
    143         instance->speed = speed;
    144         instance->manager = manager;
    145         instance->callback_out = func_out;
    146         instance->callback_in = func_in;
    147 
    148         qh_set_element_td(instance->qh, addr_to_phys(instance->tds));
    149 
    150149        usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
    151150            instance, target.address, target.endpoint);
    … …  
    153152}
    154153/*----------------------------------------------------------------------------*/
    155 /** Mark batch as failed and continue with next step.
    156  *
    157  * @param[in] instance Batch structure to use.
    158  *
    159  */
    160 void batch_abort(batch_t *instance)
    161 {
    162         assert(instance);
    163         instance->error = EIO;
    164         instance->next_step(instance);
    165 }
    166 /*----------------------------------------------------------------------------*/
    167154/** Check batch TDs for activity.
    168155 *
    … …  
    174161 * is reached.
    175162 */
    176 bool batch_is_complete(batch_t *instance)
    177 {
    178         assert(instance);
     163bool batch_is_complete(usb_transfer_batch_t *instance)
     164{
     165        assert(instance);
     166        uhci_batch_t *data = instance->private_data;
     167        assert(data);
     168
    179169        usb_log_debug2("Batch(%p) checking %d packet(s) for completion.\n",
    180             instance, instance->packets);
     170            instance, data->packets);
    181171        instance->transfered_size = 0;
    182172        size_t i = 0;
    183         for (;i < instance->packets; ++i) {
    184                 if (td_is_active(&instance->tds[i])) {
     173        for (;i < data->packets; ++i) {
     174                if (td_is_active(&data->tds[i])) {
    185175                        return false;
    186176                }
    187177
    188                 instance->error = td_status(&instance->tds[i]);
     178                instance->error = td_status(&data->tds[i]);
    189179                if (instance->error != EOK) {
    190180                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
    191                             instance, i, instance->tds[i].status);
    192                         td_print_status(&instance->tds[i]);
    193 
    194                         device_keeper_set_toggle(instance->manager,
    195                             instance->target, td_toggle(&instance->tds[i]));
     181                            instance, i, data->tds[i].status);
     182                        td_print_status(&data->tds[i]);
     183
     184                        usb_device_keeper_set_toggle(data->manager,
     185                            instance->target, instance->direction,
     186                            td_toggle(&data->tds[i]));
    196187                        if (i > 0)
    197188                                goto substract_ret;
    … …  
    199190                }
    200191
    201                 instance->transfered_size += td_act_size(&instance->tds[i]);
    202                 if (td_is_short(&instance->tds[i]))
     192                instance->transfered_size += td_act_size(&data->tds[i]);
     193                if (td_is_short(&data->tds[i]))
    203194                        goto substract_ret;
    204195        }
    … …  
    214205 * Uses genercir control function with pids OUT and IN.
    215206 */
    216 void batch_control_write(batch_t *instance)
     207void batch_control_write(usb_transfer_batch_t *instance)
    217208{
    218209        assert(instance);
    … …  
    231222 * Uses generic control with pids IN and OUT.
    232223 */
    233 void batch_control_read(batch_t *instance)
     224void batch_control_read(usb_transfer_batch_t *instance)
    234225{
    235226        assert(instance);
    … …  
    245236 * Data transaction with PID_IN.
    246237 */
    247 void batch_interrupt_in(batch_t *instance)
    248 {
    249         assert(instance);
     238void batch_interrupt_in(usb_transfer_batch_t *instance)
     239{
     240        assert(instance);
     241        instance->direction = USB_DIRECTION_IN;
    250242        batch_data(instance, USB_PID_IN);
    251243        instance->next_step = batch_call_in_and_dispose;
    … …  
    259251 * Data transaction with PID_OUT.
    260252 */
    261 void batch_interrupt_out(batch_t *instance)
    262 {
    263         assert(instance);
     253void batch_interrupt_out(usb_transfer_batch_t *instance)
     254{
     255        assert(instance);
     256        instance->direction = USB_DIRECTION_OUT;
    264257        /* We are data out, we are supposed to provide data */
    265258        memcpy(instance->transport_buffer, instance->buffer,
    … …  
    276269 * Data transaction with PID_IN.
    277270 */
    278 void batch_bulk_in(batch_t *instance)
     271void batch_bulk_in(usb_transfer_batch_t *instance)
    279272{
    280273        assert(instance);
    281274        batch_data(instance, USB_PID_IN);
     275        instance->direction = USB_DIRECTION_IN;
    282276        instance->next_step = batch_call_in_and_dispose;
    283277        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
    … …  
    290284 * Data transaction with PID_OUT.
    291285 */
    292 void batch_bulk_out(batch_t *instance)
    293 {
    294         assert(instance);
     286void batch_bulk_out(usb_transfer_batch_t *instance)
     287{
     288        assert(instance);
     289        instance->direction = USB_DIRECTION_OUT;
    295290        /* We are data out, we are supposed to provide data */
    296291        memcpy(instance->transport_buffer, instance->buffer,
    … …  
    309304 * The last packet is marked with IOC flag.
    310305 */
    311 void batch_data(batch_t *instance, usb_packet_id pid)
    312 {
    313         assert(instance);
     306void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid)
     307{
     308        assert(instance);
     309        uhci_batch_t *data = instance->private_data;
     310        assert(data);
     311
    314312        const bool low_speed = instance->speed == USB_SPEED_LOW;
    315         int toggle =
    316             device_keeper_get_toggle(instance->manager, instance->target);
     313        int toggle = usb_device_keeper_get_toggle(
     314            data->manager, instance->target, instance->direction);
    317315        assert(toggle == 0 || toggle == 1);
    318316
    … …  
    320318        size_t remain_size = instance->buffer_size;
    321319        while (remain_size > 0) {
    322                 char *data =
     320                char *trans_data =
    323321                    instance->transport_buffer + instance->buffer_size
    324322                    - remain_size;
    … …  
    328326                    remain_size : instance->max_packet_size;
    329327
    330                 td_t *next_packet = (packet + 1 < instance->packets)
    331                     ? &instance->tds[packet + 1] : NULL;
    332 
    333                 assert(packet < instance->packets);
     328                td_t *next_packet = (packet + 1 < data->packets)
     329                    ? &data->tds[packet + 1] : NULL;
     330
     331                assert(packet < data->packets);
    334332                assert(packet_size <= remain_size);
    335333
    336334                td_init(
    337                     &instance->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
    338                     toggle, false, low_speed, instance->target, pid, data,
     335                    &data->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
     336                    toggle, false, low_speed, instance->target, pid, trans_data,
    339337                    next_packet);
    340338
    … …  
    344342                ++packet;
    345343        }
    346         td_set_ioc(&instance->tds[packet - 1]);
    347         device_keeper_set_toggle(instance->manager, instance->target, toggle);
     344        td_set_ioc(&data->tds[packet - 1]);
     345        usb_device_keeper_set_toggle(data->manager, instance->target,
     346            instance->direction, toggle);
    348347}
    349348/*----------------------------------------------------------------------------*/
    … …  
    359358 * The last packet is marked with IOC.
    360359 */
    361 void batch_control(batch_t *instance,
     360void batch_control(usb_transfer_batch_t *instance,
    362361   usb_packet_id data_stage, usb_packet_id status_stage)
    363362{
    364363        assert(instance);
     364        uhci_batch_t *data = instance->private_data;
     365        assert(data);
     366        assert(data->packets >= 2);
    365367
    366368        const bool low_speed = instance->speed == USB_SPEED_LOW;
    367369        int toggle = 0;
    368370        /* setup stage */
    369         td_init(instance->tds, DEFAULT_ERROR_COUNT,
    370             instance->setup_size, toggle, false, low_speed, instance->target,
    371             USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
     371        td_init(
     372            data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, toggle, false,
     373            low_speed, instance->target, USB_PID_SETUP, instance->setup_buffer,
     374            &data->tds[1]);
    372375
    373376        /* data stage */
    … …  
    375378        size_t remain_size = instance->buffer_size;
    376379        while (remain_size > 0) {
    377                 char *data =
     380                char *control_data =
    378381                    instance->transport_buffer + instance->buffer_size
    379382                    - remain_size;
    … …  
    386389
    387390                td_init(
    388                     &instance->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
     391                    &data->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
    389392                    toggle, false, low_speed, instance->target, data_stage,
    390                     data, &instance->tds[packet + 1]);
     393                    control_data, &data->tds[packet + 1]);
    391394
    392395                ++packet;
    393                 assert(packet < instance->packets);
     396                assert(packet < data->packets);
    394397                assert(packet_size <= remain_size);
    395398                remain_size -= packet_size;
    … …  
    397400
    398401        /* status stage */
    399         assert(packet == instance->packets - 1);
    400         td_init(&instance->tds[packet], DEFAULT_ERROR_COUNT,
    401             0, 1, false, low_speed, instance->target, status_stage, NULL, NULL);
    402 
    403         td_set_ioc(&instance->tds[packet]);
     402        assert(packet == data->packets - 1);
     403
     404        td_init(
     405            &data->tds[packet], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
     406            instance->target, status_stage, NULL, NULL);
     407        td_set_ioc(&data->tds[packet]);
     408
    404409        usb_log_debug2("Control last TD status: %x.\n",
    405             instance->tds[packet].status);
    406 }
    407 /*----------------------------------------------------------------------------*/
    408 /** Prepare data, get error status and call callback in.
    409  *
    410  * @param[in] instance Batch structure to use.
    411  * Copies data from transport buffer, and calls callback with appropriate
    412  * parameters.
    413  */
    414 void batch_call_in(batch_t *instance)
    415 {
    416         assert(instance);
    417         assert(instance->callback_in);
    418 
    419         /* We are data in, we need data */
    420         memcpy(instance->buffer, instance->transport_buffer,
    421             instance->buffer_size);
    422 
    423         int err = instance->error;
    424         usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
    425             instance, instance->transfer_type, str_error(err), err,
    426             instance->transfered_size);
    427 
    428         instance->callback_in(
    429             instance->fun, err, instance->transfered_size, instance->arg);
    430 }
    431 /*----------------------------------------------------------------------------*/
    432 /** Get error status and call callback out.
    433  *
    434  * @param[in] instance Batch structure to use.
    435  */
    436 void batch_call_out(batch_t *instance)
    437 {
    438         assert(instance);
    439         assert(instance->callback_out);
    440 
    441         int err = instance->error;
    442         usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n",
    443             instance, instance->transfer_type, str_error(err), err);
    444         instance->callback_out(instance->fun,
    445             err, instance->arg);
     410            data->tds[packet].status);
     411}
     412/*----------------------------------------------------------------------------*/
     413qh_t * batch_qh(usb_transfer_batch_t *instance)
     414{
     415        assert(instance);
     416        uhci_batch_t *data = instance->private_data;
     417        assert(data);
     418        return data->qh;
    446419}
    447420/*----------------------------------------------------------------------------*/
    … …  
    450423 * @param[in] instance Batch structure to use.
    451424 */
    452 void batch_call_in_and_dispose(batch_t *instance)
    453 {
    454         assert(instance);
    455         batch_call_in(instance);
     425void batch_call_in_and_dispose(usb_transfer_batch_t *instance)
     426{
     427        assert(instance);
     428        usb_transfer_batch_call_in(instance);
    456429        batch_dispose(instance);
    457430}
    … …  
    461434 * @param[in] instance Batch structure to use.
    462435 */
    463 void batch_call_out_and_dispose(batch_t *instance)
    464 {
    465         assert(instance);
    466         batch_call_out(instance);
     436void batch_call_out_and_dispose(usb_transfer_batch_t *instance)
     437{
     438        assert(instance);
     439        usb_transfer_batch_call_out(instance);
    467440        batch_dispose(instance);
    468441}
    … …  
    472445 * @param[in] instance Batch structure to use.
    473446 */
    474 void batch_dispose(batch_t *instance)
    475 {
    476         assert(instance);
     447void batch_dispose(usb_transfer_batch_t *instance)
     448{
     449        assert(instance);
     450        uhci_batch_t *data = instance->private_data;
     451        assert(data);
    477452        usb_log_debug("Batch(%p) disposing.\n", instance);
    478453        /* free32 is NULL safe */
    479         free32(instance->tds);
    480         free32(instance->qh);
     454        free32(data->tds);
     455        free32(data->qh);
    481456        free32(instance->setup_buffer);
    482457        free32(instance->transport_buffer);
     458        free(data);
    483459        free(instance);
    484460}

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

    rfd9f6e4c r41ef5b9  
    3939#include <usbhc_iface.h>
    4040#include <usb/usb.h>
     41#include <usb/host/device_keeper.h>
     42#include <usb/host/batch.h>
    4143
    42 #include "uhci_struct/transfer_descriptor.h"
    4344#include "uhci_struct/queue_head.h"
    44 #include "utils/device_keeper.h"
    4545
    46 typedef struct batch
    47 {
    48         link_t link;
    49         usb_speed_t speed;
    50         usb_target_t target;
    51         usb_transfer_type_t transfer_type;
    52         usbhc_iface_transfer_in_callback_t callback_in;
    53         usbhc_iface_transfer_out_callback_t callback_out;
    54         void *arg;
    55         char *transport_buffer;
    56         char *setup_buffer;
    57         size_t setup_size;
    58         char *buffer;
    59         size_t buffer_size;
    60         size_t max_packet_size;
    61         size_t packets;
    62         size_t transfered_size;
    63         int error;
    64         ddf_fun_t *fun;
    65         qh_t *qh;
    66         td_t *tds;
    67         void (*next_step)(struct batch*);
    68         device_keeper_t *manager;
    69 } batch_t;
    70 
    71 batch_t * batch_get(
     46usb_transfer_batch_t * batch_get(
    7247    ddf_fun_t *fun,
    7348                usb_target_t target,
    … …  
    8257    usbhc_iface_transfer_out_callback_t func_out,
    8358                void *arg,
    84                 device_keeper_t *manager
     59                usb_device_keeper_t *manager
    8560                );
    8661
    87 void batch_dispose(batch_t *instance);
     62void batch_dispose(usb_transfer_batch_t *instance);
    8863
    89 void batch_abort(batch_t *instance);
     64bool batch_is_complete(usb_transfer_batch_t *instance);
    9065
    91 bool batch_is_complete(batch_t *instance);
     66void batch_control_write(usb_transfer_batch_t *instance);
    9267
    93 void batch_control_write(batch_t *instance);
     68void batch_control_read(usb_transfer_batch_t *instance);
    9469
    95 void batch_control_read(batch_t *instance);
     70void batch_interrupt_in(usb_transfer_batch_t *instance);
    9671
    97 void batch_interrupt_in(batch_t *instance);
     72void batch_interrupt_out(usb_transfer_batch_t *instance);
    9873
    99 void batch_interrupt_out(batch_t *instance);
     74void batch_bulk_in(usb_transfer_batch_t *instance);
    10075
    101 void batch_bulk_in(batch_t *instance);
     76void batch_bulk_out(usb_transfer_batch_t *instance);
    10277
    103 void batch_bulk_out(batch_t *instance);
     78qh_t * batch_qh(usb_transfer_batch_t *instance);
    10479#endif
    10580/**

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

    rfd9f6e4c r41ef5b9  
    4141#include "iface.h"
    4242#include "uhci_hc.h"
    43 #include "utils/device_keeper.h"
    4443
    4544/** Reserve default address interface function
    … …  
    5655        assert(hc);
    5756        usb_log_debug("Default address request with speed %d.\n", speed);
    58         device_keeper_reserve_default(&hc->device_manager, speed);
     57        usb_device_keeper_reserve_default_address(&hc->device_manager, speed);
    5958        return EOK;
    6059}
    … …  
    7170        assert(hc);
    7271        usb_log_debug("Default address release.\n");
    73         device_keeper_release_default(&hc->device_manager);
     72        usb_device_keeper_release_default_address(&hc->device_manager);
    7473        return EOK;
    7574}
    … …  
    9190
    9291        usb_log_debug("Address request with speed %d.\n", speed);
    93         *address = device_keeper_request(&hc->device_manager, speed);
     92        *address = device_keeper_get_free_address(&hc->device_manager, speed);
    9493        usb_log_debug("Address request with result: %d.\n", *address);
    9594        if (*address <= 0)
    … …  
    112111        assert(hc);
    113112        usb_log_debug("Address bind %d-%d.\n", address, handle);
    114         device_keeper_bind(&hc->device_manager, address, handle);
     113        usb_device_keeper_bind(&hc->device_manager, address, handle);
    115114        return EOK;
    116115}
    … …  
    128127        assert(hc);
    129128        usb_log_debug("Address release %d.\n", address);
    130         device_keeper_release(&hc->device_manager, address);
     129        usb_device_keeper_release(&hc->device_manager, address);
    131130        return EOK;
    132131}
    … …  
    150149        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    151150        assert(hc);
    152         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     151        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    153152
    154153        usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
    155154            target.address, target.endpoint, size, max_packet_size);
    156155
    157         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     156        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    158157            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
    159158            &hc->device_manager);
    … …  
    187186        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    188187        assert(hc);
    189         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     188        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    190189        usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
    191190            target.address, target.endpoint, size, max_packet_size);
    192191
    193         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     192        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    194193            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
    195194                        &hc->device_manager);
    … …  
    223222        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    224223        assert(hc);
    225         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     224        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    226225
    227226        usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
    228227            target.address, target.endpoint, size, max_packet_size);
    229228
    230         batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     229        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
    231230            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
    232231            &hc->device_manager);
    … …  
    260259        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    261260        assert(hc);
    262         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     261        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    263262        usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
    264263            target.address, target.endpoint, size, max_packet_size);
    265264
    266         batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     265        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
    267266            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
    268267            &hc->device_manager);
    … …  
    299298        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    300299        assert(hc);
    301         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     300        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    302301        usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
    303302            speed, target.address, target.endpoint, size, max_packet_size);
    … …  
    306305                return EINVAL;
    307306
    308         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     307        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    309308            max_packet_size, speed, data, size, setup_data, setup_size,
    310309            NULL, callback, arg, &hc->device_manager);
    311310        if (!batch)
    312311                return ENOMEM;
    313         device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
     312        usb_device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
    314313        batch_control_write(batch);
    315314        const int ret = uhci_hc_schedule(hc, batch);
    … …  
    342341        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    343342        assert(hc);
    344         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     343        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    345344
    346345        usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
    347346            speed, target.address, target.endpoint, size, max_packet_size);
    348         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     347        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    349348            max_packet_size, speed, data, size, setup_data, setup_size, callback,
    350349            NULL, arg, &hc->device_manager);

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

    rfd9f6e4c r41ef5b9  
    3838
    3939static void transfer_list_remove_batch(
    40     transfer_list_t *instance, batch_t *batch);
     40    transfer_list_t *instance, usb_transfer_batch_t *batch);
    4141/*----------------------------------------------------------------------------*/
    4242/** Initialize transfer list structures.
    … …  
    9292 * The batch is added to the end of the list and queue.
    9393 */
    94 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch)
     94void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch)
    9595{
    9696        assert(instance);
    … …  
    9898        usb_log_debug2("Queue %s: Adding batch(%p).\n", instance->name, batch);
    9999
    100         const uint32_t pa = addr_to_phys(batch->qh);
     100        const uint32_t pa = addr_to_phys(batch_qh(batch));
    101101        assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
    102102
    103103        /* New batch will be added to the end of the current list
    104104         * so set the link accordingly */
    105         qh_set_next_qh(batch->qh, instance->queue_head->next);
     105        qh_set_next_qh(batch_qh(batch), instance->queue_head->next);
    106106
    107107        fibril_mutex_lock(&instance->guard);
    … …  
    115115        } else {
    116116                /* There is something scheduled */
    117                 batch_t *last = list_get_instance(
    118                     instance->batch_list.prev, batch_t, link);
    119                 qh_set_next_qh(last->qh, pa);
     117                usb_transfer_batch_t *last = list_get_instance(
     118                    instance->batch_list.prev, usb_transfer_batch_t, link);
     119                qh_set_next_qh(batch_qh(last), pa);
    120120        }
    121121        /* Add to the driver list */
    122122        list_append(&batch->link, &instance->batch_list);
    123123
    124         batch_t *first = list_get_instance(
    125             instance->batch_list.next, batch_t, link);
     124        usb_transfer_batch_t *first = list_get_instance(
     125            instance->batch_list.next, usb_transfer_batch_t, link);
    126126        usb_log_debug("Batch(%p) added to queue %s, first is %p.\n",
    127127                batch, instance->name, first);
    … …  
    148148        while (current != &instance->batch_list) {
    149149                link_t *next = current->next;
    150                 batch_t *batch = list_get_instance(current, batch_t, link);
     150                usb_transfer_batch_t *batch = list_get_instance(current, usb_transfer_batch_t, link);
    151151
    152152                if (batch_is_complete(batch)) {
    … …  
    162162                link_t *item = done.next;
    163163                list_remove(item);
    164                 batch_t *batch = list_get_instance(item, batch_t, link);
     164                usb_transfer_batch_t *batch = list_get_instance(item, usb_transfer_batch_t, link);
    165165                batch->next_step(batch);
    166166        }
    … …  
    176176        while (list_empty(&instance->batch_list)) {
    177177                link_t *current = instance->batch_list.next;
    178                 batch_t *batch = list_get_instance(current, batch_t, link);
     178                usb_transfer_batch_t *batch = list_get_instance(current, usb_transfer_batch_t, link);
    179179                transfer_list_remove_batch(instance, batch);
    180                 batch_abort(batch);
     180                usb_transfer_batch_finish(batch, EIO);
    181181        }
    182182        fibril_mutex_unlock(&instance->guard);
    … …  
    191191 * Does not lock the transfer list, caller is responsible for that.
    192192 */
    193 void transfer_list_remove_batch(transfer_list_t *instance, batch_t *batch)
    194 {
    195         assert(instance);
     193void transfer_list_remove_batch(transfer_list_t *instance, usb_transfer_batch_t *batch)
     194{
     195        assert(instance);
     196        assert(instance->queue_head);
    196197        assert(batch);
    197         assert(instance->queue_head);
    198         assert(batch->qh);
     198        assert(batch_qh(batch));
    199199        usb_log_debug2(
    200200            "Queue %s: removing batch(%p).\n", instance->name, batch);
    … …  
    204204        if (batch->link.prev == &instance->batch_list) {
    205205                /* I'm the first one here */
    206                 qh_set_element_qh(instance->queue_head, batch->qh->next);
     206                qh_set_element_qh(instance->queue_head, batch_qh(batch)->next);
    207207                pos = "FIRST";
    208208        } else {
    209                 batch_t *prev =
    210                     list_get_instance(batch->link.prev, batch_t, link);
    211                 qh_set_next_qh(prev->qh, batch->qh->next);
     209                usb_transfer_batch_t *prev =
     210                    list_get_instance(batch->link.prev, usb_transfer_batch_t, link);
     211                qh_set_next_qh(batch_qh(prev), batch_qh(batch)->next);
    212212                pos = "NOT FIRST";
    213213        }
    … …  
    215215        list_remove(&batch->link);
    216216        usb_log_debug("Batch(%p) removed (%s) from %s, next element %x.\n",
    217             batch, pos, instance->name, batch->qh->next);
     217            batch, pos, instance->name, batch_qh(batch)->next);
    218218}
    219219/**

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

    rfd9f6e4c r41ef5b9  
    6666void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next);
    6767
    68 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);
     68void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch);
    6969
    7070void transfer_list_remove_finished(transfer_list_t *instance);

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

    rfd9f6e4c r41ef5b9  
    7070{
    7171        assert(fun);
    72         device_keeper_t *manager = &((uhci_t*)fun->dev->driver_data)->hc.device_manager;
    73 
    74         usb_address_t addr = device_keeper_find(manager, handle);
     72        usb_device_keeper_t *manager = &((uhci_t*)fun->dev->driver_data)->hc.device_manager;
     73
     74        usb_address_t addr = usb_device_keeper_find(manager, handle);
    7575        if (addr < 0) {
    7676                return addr;

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

    rfd9f6e4c r41ef5b9  
    121121                    fibril_create(uhci_hc_interrupt_emulator, instance);
    122122                fibril_add_ready(instance->cleaner);
     123        } else {
     124                /* TODO: enable interrupts here */
    123125        }
    124126
    … …  
    234236
    235237        /* Init device keeper*/
    236         device_keeper_init(&instance->device_manager);
     238        usb_device_keeper_init(&instance->device_manager);
    237239        usb_log_debug("Initialized device manager.\n");
    238240
    … …  
    316318 * Checks for bandwidth availability and appends the batch to the proper queue.
    317319 */
    318 int uhci_hc_schedule(uhci_hc_t *instance, batch_t *batch)
     320int uhci_hc_schedule(uhci_hc_t *instance, usb_transfer_batch_t *batch)
    319321{
    320322        assert(instance);

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

    rfd9f6e4c r41ef5b9  
    4242
    4343#include <usbhc_iface.h>
     44#include <usb/host/device_keeper.h>
    4445
    4546#include "batch.h"
    4647#include "transfer_list.h"
    47 #include "utils/device_keeper.h"
    4848
    4949typedef struct uhci_regs {
    … …  
    8383
    8484typedef struct uhci_hc {
    85         device_keeper_t device_manager;
     85        usb_device_keeper_t device_manager;
    8686
    8787        regs_t *registers;
    … …  
    109109    void *regs, size_t reg_size, bool interupts);
    110110
    111 int uhci_hc_schedule(uhci_hc_t *instance, batch_t *batch);
     111int uhci_hc_schedule(uhci_hc_t *instance, usb_transfer_batch_t *batch);
    112112
    113113void uhci_hc_interrupt(uhci_hc_t *instance, uint16_t status);

  • uspace/drv/usbflbk/main.c

    rfd9f6e4c r41ef5b9  
    11/*
    2  * Copyright (c) 2011 Jan Vesely
     2 * Copyright (c) 2011 Vojtech Horky
    33 * All rights reserved.
    44 *
    … …  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28 /** @addtogroup drvusbohcihc
     28
     29/** @addtogroup drvusbfallback
    2930 * @{
    3031 */
    31 /** @file
    32  * @brief OHCI Host controller driver routines
     32/**
     33 * @file
     34 * Main routines of USB fallback driver.
    3335 */
     36#include <usb/devdrv.h>
     37#include <usb/debug.h>
    3438#include <errno.h>
    3539#include <str_error.h>
    36 #include <adt/list.h>
    37 #include <libarch/ddi.h>
    3840
    39 #include <usb/debug.h>
    40 #include <usb/usb.h>
    41 #include <usb/ddfiface.h>
    42 #include <usb_iface.h>
     41#define NAME "usbflbk"
    4342
    44 #include "ohci_hc.h"
     43/** Callback when new device is attached and recognized by DDF.
     44 *
     45 * @param dev Representation of a generic DDF device.
     46 * @return Error code.
     47 */
     48static int usbfallback_add_device(usb_device_t *dev)
     49{
     50        int rc;
     51        const char *fun_name = "ctl";
    4552
    46 int ohci_hc_init(ohci_hc_t *instance, ddf_fun_t *fun,
    47     uintptr_t regs, size_t reg_size, bool interrupts)
    48 {
    49         assert(instance);
    50         int ret = pio_enable((void*)regs, reg_size, (void**)&instance->registers);
    51         if (ret != EOK) {
    52                 usb_log_error("Failed to gain access to device registers.\n");
    53                 return ret;
     53        ddf_fun_t *ctl_fun = ddf_fun_create(dev->ddf_dev, fun_exposed,
     54            fun_name);
     55        if (ctl_fun == NULL) {
     56                usb_log_error("Failed to create control function.\n");
     57                return ENOMEM;
    5458        }
    55         instance->registers->interrupt_disable = 0;
    56         /* enable interrupt on root hub status change */
    57         instance->registers->interupt_enable |= IE_RHSC | IE_MIE;
     59        rc = ddf_fun_bind(ctl_fun);
     60        if (rc != EOK) {
     61                usb_log_error("Failed to bind control function: %s.\n",
     62                    str_error(rc));
     63                return rc;
     64        }
    5865
     66        usb_log_info("Pretending to control %s `%s'" \
     67            " (node `%s', handle %llu).\n",
     68            dev->interface_no < 0 ? "device" : "interface",
     69            dev->ddf_dev->name, fun_name, dev->ddf_dev->handle);
    5970
    60         ohci_rh_init(&instance->rh, instance->registers);
    61         /* TODO: implement */
    62         /* TODO: register root hub */
    6371        return EOK;
    6472}
    65 /*----------------------------------------------------------------------------*/
    66 int ohci_hc_schedule(ohci_hc_t *instance, batch_t *batch)
     73
     74/** USB fallback driver ops. */
     75static usb_driver_ops_t usbfallback_driver_ops = {
     76        .add_device = usbfallback_add_device,
     77};
     78
     79/** USB fallback driver. */
     80static usb_driver_t usbfallback_driver = {
     81        .name = NAME,
     82        .ops = &usbfallback_driver_ops,
     83        .endpoints = NULL
     84};
     85
     86int main(int argc, char *argv[])
    6787{
    68         assert(instance);
    69         assert(batch);
    70         if (batch->target.address == instance->rh.address) {
    71                 ohci_rh_request(&instance->rh, batch);
    72                 return EOK;
    73         }
    74         /* TODO: implement */
    75         return EOK;
     88        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
     89
     90        return usb_driver_main(&usbfallback_driver);
    7691}
    77 /*----------------------------------------------------------------------------*/
    78 void ohci_hc_interrupt(ohci_hc_t *instance, uint16_t status)
    79 {
    80         assert(instance);
    81         /* TODO: Check for interrupt cause */
    82         ohci_rh_interrupt(&instance->rh);
    83         /* TODO: implement */
    84 }
     92
    8593/**
    8694 * @}

  • uspace/drv/usbhid/hiddev.c

    rfd9f6e4c r41ef5b9  
    184184 *                     successfuly initialize the structure.
    185185 *
    186  * @sa usb_endpoint_pipe_initialize_from_configuration(),
     186 * @sa usb_pipe_initialize_from_configuration(),
    187187 *     usbhid_dev_get_report_descriptor()
    188188 */
    … …  
    218218        };
    219219       
    220         rc = usb_endpoint_pipe_initialize_from_configuration(
     220        rc = usb_pipe_initialize_from_configuration(
    221221            endpoint_mapping, 1, descriptors, descriptors_size,
    222222            &hid_dev->wire);
    … …  
    359359 * @return Other value inherited from one of functions
    360360 *         usb_device_connection_initialize_from_device(),
    361  *         usb_endpoint_pipe_initialize_default_control(),
    362  *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
     361 *         usb_pipe_initialize_default_control(),
     362 *         usb_pipe_start_session(), usb_pipe_end_session(),
    363363 *         usbhid_dev_process_descriptors().
    364364 *
    … …  
    404404         * Initialize device pipes.
    405405         */
    406         rc = usb_endpoint_pipe_initialize_default_control(&hid_dev->ctrl_pipe,
     406        rc = usb_pipe_initialize_default_control(&hid_dev->ctrl_pipe,
    407407            &hid_dev->wire);
    408408        if (rc != EOK) {
    … …  
    411411                return rc;
    412412        }
    413         rc = usb_endpoint_pipe_probe_default_control(&hid_dev->ctrl_pipe);
     413        rc = usb_pipe_probe_default_control(&hid_dev->ctrl_pipe);
    414414        if (rc != EOK) {
    415415                usb_log_error("Probing default control pipe failed: %s.\n",
    … …  
    430430         * Get descriptors, parse descriptors and save endpoints.
    431431         */
    432         rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
     432        rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
    433433        if (rc != EOK) {
    434434                usb_log_error("Failed to start session on the control pipe: %s"
    … …  
    440440        if (rc != EOK) {
    441441                /* TODO: end session?? */
    442                 usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
     442                usb_pipe_end_session(&hid_dev->ctrl_pipe);
    443443                usb_log_error("Failed to process descriptors: %s.\n",
    444444                    str_error(rc));
    … …  
    446446        }
    447447       
    448         rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
     448        rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
    449449        if (rc != EOK) {
    450450                usb_log_warning("Failed to start session on the control pipe: "

  • uspace/drv/usbhid/hiddev.h

    rfd9f6e4c r41ef5b9  
    6868        usb_device_connection_t wire;
    6969        /** USB pipe corresponding to the default Control endpoint. */
    70         usb_endpoint_pipe_t ctrl_pipe;
     70        usb_pipe_t ctrl_pipe;
    7171        /** USB pipe corresponding to the Interrupt In (polling) pipe. */
    72         usb_endpoint_pipe_t poll_pipe;
     72        usb_pipe_t poll_pipe;
    7373       
    7474        /** Polling interval retreived from the Interface descriptor. */

  • uspace/drv/usbhid/hidreq.c

    rfd9f6e4c r41ef5b9  
    5757 * @retval EINVAL if no HID device is given.
    5858 * @return Other value inherited from one of functions
    59  *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
     59 *         usb_pipe_start_session(), usb_pipe_end_session(),
    6060 *         usb_control_request_set().
    6161 */
    … …  
    7676        int rc, sess_rc;
    7777       
    78         sess_rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
     78        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
    7979        if (sess_rc != EOK) {
    8080                usb_log_warning("Failed to start a session: %s.\n",
    … …  
    9292            USB_HIDREQ_SET_REPORT, value, hid_dev->iface, buffer, buf_size);
    9393
    94         sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
     94        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
    9595
    9696        if (rc != EOK) {
    … …  
    119119 * @retval EINVAL if no HID device is given.
    120120 * @return Other value inherited from one of functions
    121  *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
     121 *         usb_pipe_start_session(), usb_pipe_end_session(),
    122122 *         usb_control_request_set().
    123123 */
    … …  
    137137        int rc, sess_rc;
    138138       
    139         sess_rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
     139        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
    140140        if (sess_rc != EOK) {
    141141                usb_log_warning("Failed to start a session: %s.\n",
    … …  
    151151            USB_HIDREQ_SET_PROTOCOL, protocol, hid_dev->iface, NULL, 0);
    152152
    153         sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
     153        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
    154154
    155155        if (rc != EOK) {
    … …  
    179179 * @retval EINVAL if no HID device is given.
    180180 * @return Other value inherited from one of functions
    181  *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
     181 *         usb_pipe_start_session(), usb_pipe_end_session(),
    182182 *         usb_control_request_set().
    183183 */
    … …  
    197197        int rc, sess_rc;
    198198       
    199         sess_rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
     199        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
    200200        if (sess_rc != EOK) {
    201201                usb_log_warning("Failed to start a session: %s.\n",
    … …  
    213213            USB_HIDREQ_SET_IDLE, value, hid_dev->iface, NULL, 0);
    214214
    215         sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
     215        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
    216216
    217217        if (rc != EOK) {
    … …  
    244244 * @retval EINVAL if no HID device is given.
    245245 * @return Other value inherited from one of functions
    246  *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
     246 *         usb_pipe_start_session(), usb_pipe_end_session(),
    247247 *         usb_control_request_set().
    248248 */
    … …  
    263263        int rc, sess_rc;
    264264       
    265         sess_rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
     265        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
    266266        if (sess_rc != EOK) {
    267267                usb_log_warning("Failed to start a session: %s.\n",
    … …  
    280280            actual_size);
    281281
    282         sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
     282        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
    283283
    284284        if (rc != EOK) {
    … …  
    307307 * @retval EINVAL if no HID device is given.
    308308 * @return Other value inherited from one of functions
    309  *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
     309 *         usb_pipe_start_session(), usb_pipe_end_session(),
    310310 *         usb_control_request_set().
    311311 */
    … …  
    325325        int rc, sess_rc;
    326326       
    327         sess_rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
     327        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
    328328        if (sess_rc != EOK) {
    329329                usb_log_warning("Failed to start a session: %s.\n",
    … …  
    342342            USB_HIDREQ_GET_PROTOCOL, 0, hid_dev->iface, buffer, 1, &actual_size);
    343343
    344         sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
     344        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
    345345
    346346        if (rc != EOK) {
    … …  
    378378 * @retval EINVAL if no HID device is given.
    379379 * @return Other value inherited from one of functions
    380  *         usb_endpoint_pipe_start_session(), usb_endpoint_pipe_end_session(),
     380 *         usb_pipe_start_session(), usb_pipe_end_session(),
    381381 *         usb_control_request_set().
    382382 */
    … …  
    396396        int rc, sess_rc;
    397397       
    398         sess_rc = usb_endpoint_pipe_start_session(&hid_dev->ctrl_pipe);
     398        sess_rc = usb_pipe_start_session(&hid_dev->ctrl_pipe);
    399399        if (sess_rc != EOK) {
    400400                usb_log_warning("Failed to start a session: %s.\n",
    … …  
    415415            &actual_size);
    416416
    417         sess_rc = usb_endpoint_pipe_end_session(&hid_dev->ctrl_pipe);
     417        sess_rc = usb_pipe_end_session(&hid_dev->ctrl_pipe);
    418418
    419419        if (rc != EOK) {

  • uspace/drv/usbhid/kbddev.c

    rfd9f6e4c r41ef5b9  
    780780
    781781        while (true) {
    782                 sess_rc = usb_endpoint_pipe_start_session(
     782                sess_rc = usb_pipe_start_session(
    783783                    &kbd_dev->hid_dev->poll_pipe);
    784784                if (sess_rc != EOK) {
    … …  
    788788                }
    789789
    790                 rc = usb_endpoint_pipe_read(&kbd_dev->hid_dev->poll_pipe,
     790                rc = usb_pipe_read(&kbd_dev->hid_dev->poll_pipe,
    791791                    buffer, BOOTP_BUFFER_SIZE, &actual_size);
    792792               
    793                 sess_rc = usb_endpoint_pipe_end_session(
     793                sess_rc = usb_pipe_end_session(
    794794                    &kbd_dev->hid_dev->poll_pipe);
    795795

  • uspace/drv/usbhub/main.c

    rfd9f6e4c r41ef5b9  
    4242#include "usbhub_private.h"
    4343
    44 
    45 usb_endpoint_description_t hub_status_change_endpoint_description = {
     44/** Hub status-change endpoint description.
     45 *
     46 * For more information see section 11.15.1 of USB 1.1 specification.
     47 */
     48static usb_endpoint_description_t hub_status_change_endpoint_description = {
    4649        .transfer_type = USB_TRANSFER_INTERRUPT,
    4750        .direction = USB_DIRECTION_IN,
    … …  
    5760};
    5861
     62static usb_endpoint_description_t *usb_hub_endpoints[] = {
     63        &hub_status_change_endpoint_description,
     64        NULL
     65};
     66
    5967static usb_driver_t usb_hub_driver = {
    60         .name = "usbhub",
    61         .ops = &usb_hub_driver_ops
     68        .name = NAME,
     69        .ops = &usb_hub_driver_ops,
     70        .endpoints = usb_hub_endpoints
    6271};
    6372
    … …  
    6574int main(int argc, char *argv[])
    6675{
     76        printf(NAME ": HelenOS USB hub driver.\n");
     77
    6778        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
    68         usb_log_info("starting hub driver\n");
    69 
    7079       
    71         usb_hub_driver.endpoints = (usb_endpoint_description_t**)
    72                         malloc(2 * sizeof(usb_endpoint_description_t*));
    73         usb_hub_driver.endpoints[0] = &hub_status_change_endpoint_description;
    74         usb_hub_driver.endpoints[1] = NULL;
    75 
    7680        return usb_driver_main(&usb_hub_driver);
    7781}

  • uspace/drv/usbhub/usbhub.c

    rfd9f6e4c r41ef5b9  
    157157static int usb_hub_set_configuration(usb_hub_info_t * hub_info){
    158158        //device descriptor
    159         usb_standard_device_descriptor_t std_descriptor;
    160         int opResult = usb_request_get_device_descriptor(
    161                 &hub_info->usb_device->ctrl_pipe,
    162             &std_descriptor);
    163         if(opResult!=EOK){
    164                 usb_log_error("could not get device descriptor, %d\n",opResult);
    165                 return opResult;
    166         }
     159        usb_standard_device_descriptor_t *std_descriptor
     160            = &hub_info->usb_device->descriptors.device;
    167161        usb_log_info("hub has %d configurations\n",
    168                         std_descriptor.configuration_count);
    169         if(std_descriptor.configuration_count<1){
     162            std_descriptor->configuration_count);
     163        if(std_descriptor->configuration_count<1){
    170164                usb_log_error("THERE ARE NO CONFIGURATIONS AVAILABLE\n");
    171165                //shouldn`t I return?
    172         }
    173 
    174         /* Retrieve full configuration descriptor. */
    175         uint8_t *descriptors = NULL;
    176         size_t descriptors_size = 0;
    177         opResult = usb_request_get_full_configuration_descriptor_alloc(
    178             &hub_info->usb_device->ctrl_pipe, 0,
    179             (void **) &descriptors, &descriptors_size);
    180         if (opResult != EOK) {
    181                 usb_log_error("Could not get configuration descriptor: %s.\n",
    182                     str_error(opResult));
    183                 return opResult;
    184         }
     166                //definitely
     167                return EINVAL;
     168        }
     169
    185170        usb_standard_configuration_descriptor_t *config_descriptor
    186             = (usb_standard_configuration_descriptor_t *) descriptors;
     171            = (usb_standard_configuration_descriptor_t *)
     172            hub_info->usb_device->descriptors.configuration;
    187173
    188174        /* Set configuration. */
    189         opResult = usb_request_set_configuration(&hub_info->usb_device->ctrl_pipe,
     175        int opResult = usb_request_set_configuration(
     176            &hub_info->usb_device->ctrl_pipe,
    190177            config_descriptor->configuration_number);
    191178
    … …  
    197184        usb_log_debug("\tused configuration %d\n",
    198185                        config_descriptor->configuration_number);
    199         free(descriptors);
     186
    200187        return EOK;
    201188}
    … …  
    224211        }
    225212       
    226         usb_endpoint_pipe_start_session(hub_info->control_pipe);
     213        usb_pipe_start_session(hub_info->control_pipe);
    227214        //set hub configuration
    228215        opResult = usb_hub_set_configuration(hub_info);
    … …  
    239226                return opResult;
    240227        }
    241         usb_endpoint_pipe_end_session(hub_info->control_pipe);
     228        usb_pipe_end_session(hub_info->control_pipe);
    242229
    243230
    244231        /// \TODO what is this?
    245         usb_log_debug("adding to ddf");
     232        usb_log_debug("Creating `hub' function.\n");
    246233        ddf_fun_t *hub_fun = ddf_fun_create(hub_info->usb_device->ddf_dev,
    247234                        fun_exposed, "hub");
    … …  
    257244        fid_t fid = fibril_create(usb_hub_control_loop, hub_info);
    258245        if (fid == 0) {
    259                 usb_log_error("failed to start monitoring fibril for new hub");
     246                usb_log_error("failed to start monitoring fibril for new hub.\n");
    260247                return ENOMEM;
    261248        }
    262249        fibril_add_ready(fid);
    263         usb_log_debug("hub fibril created");
    264         usb_log_debug("has %d ports ",hub_info->port_count);
     250        usb_log_debug("Hub fibril created.\n");
     251
     252        usb_log_info("Controlling hub `%s' (%d ports).\n",
     253            hub_info->usb_device->ddf_dev->name, hub_info->port_count);
    265254        return EOK;
    266255}
    … …  
    321310        //reset port
    322311        usb_hub_set_reset_port_request(&request, port);
    323         opResult = usb_endpoint_pipe_control_write(
     312        opResult = usb_pipe_control_write(
    324313                        hub->control_pipe,
    325314                        &request,sizeof(usb_device_request_setup_packet_t),
    … …  
    354343        }
    355344        //create connection to device
    356         usb_endpoint_pipe_t new_device_pipe;
     345        usb_pipe_t new_device_pipe;
    357346        usb_device_connection_t new_device_connection;
    358347        usb_device_connection_initialize_on_default_address(
    … …  
    360349                        &hub->connection
    361350                        );
    362         usb_endpoint_pipe_initialize_default_control(
     351        usb_pipe_initialize_default_control(
    363352                        &new_device_pipe,
    364353                        &new_device_connection);
    365         usb_endpoint_pipe_probe_default_control(&new_device_pipe);
     354        usb_pipe_probe_default_control(&new_device_pipe);
    366355
    367356        /* Request address from host controller. */
    … …  
    379368        //opResult = usb_drv_req_set_address(hc, USB_ADDRESS_DEFAULT,
    380369        //    new_device_address);
    381         usb_endpoint_pipe_start_session(&new_device_pipe);
     370        usb_pipe_start_session(&new_device_pipe);
    382371        opResult = usb_request_set_address(&new_device_pipe,new_device_address);
    383         usb_endpoint_pipe_end_session(&new_device_pipe);
     372        usb_pipe_end_session(&new_device_pipe);
    384373        if (opResult != EOK) {
    385374                usb_log_error("could not set address for new device %d\n",opResult);
    … …  
    488477        usb_log_debug("interrupt at port %d\n", port);
    489478        //determine type of change
    490         usb_endpoint_pipe_t *pipe = hub->control_pipe;
     479        usb_pipe_t *pipe = hub->control_pipe;
    491480       
    492481        int opResult;
    … …  
    499488        //endpoint 0
    500489
    501         opResult = usb_endpoint_pipe_control_read(
     490        opResult = usb_pipe_control_read(
    502491                        pipe,
    503492                        &request, sizeof(usb_device_request_setup_packet_t),
    … …  
    533522        //port reset
    534523        if (usb_port_reset_completed(&status)) {
    535                 usb_log_info("port reset complete");
     524                usb_log_info("port reset complete\n");
    536525                if (usb_port_enabled(&status)) {
    537526                        usb_hub_finalize_add_device(hub, port, usb_port_speed(&status));
    … …  
    560549int usb_hub_check_hub_changes(usb_hub_info_t * hub_info){
    561550        int opResult;
    562         opResult = usb_endpoint_pipe_start_session(
     551        opResult = usb_pipe_start_session(
    563552                        hub_info->status_change_pipe);
    564553        if(opResult != EOK){
    … …  
    578567         * Send the request.
    579568         */
    580         opResult = usb_endpoint_pipe_read(
     569        opResult = usb_pipe_read(
    581570                        hub_info->status_change_pipe,
    582571                        change_bitmap, byte_length, &actual_size
    … …  
    586575                free(change_bitmap);
    587576                usb_log_warning("something went wrong while getting status of hub\n");
    588                 usb_endpoint_pipe_end_session(hub_info->status_change_pipe);
     577                usb_pipe_end_session(hub_info->status_change_pipe);
    589578                return opResult;
    590579        }
    591580        unsigned int port;
    592         opResult = usb_endpoint_pipe_start_session(hub_info->control_pipe);
     581        opResult = usb_pipe_start_session(hub_info->control_pipe);
    593582        if(opResult!=EOK){
    594583                usb_log_error("could not start control pipe session %d\n", opResult);
    595                 usb_endpoint_pipe_end_session(hub_info->status_change_pipe);
     584                usb_pipe_end_session(hub_info->status_change_pipe);
    596585                return opResult;
    597586        }
    … …  
    600589                usb_log_error("could not start host controller session %d\n",
    601590                                opResult);
    602                 usb_endpoint_pipe_end_session(hub_info->control_pipe);
    603                 usb_endpoint_pipe_end_session(hub_info->status_change_pipe);
     591                usb_pipe_end_session(hub_info->control_pipe);
     592                usb_pipe_end_session(hub_info->status_change_pipe);
    604593                return opResult;
    605594        }
    … …  
    615604        }
    616605        usb_hc_connection_close(&hub_info->connection);
    617         usb_endpoint_pipe_end_session(hub_info->control_pipe);
    618         usb_endpoint_pipe_end_session(hub_info->status_change_pipe);
     606        usb_pipe_end_session(hub_info->control_pipe);
     607        usb_pipe_end_session(hub_info->status_change_pipe);
    619608        free(change_bitmap);
    620609        return EOK;

  • uspace/drv/usbhub/usbhub.h

    rfd9f6e4c r41ef5b9  
    4848
    4949
    50 /** Hub status-change endpoint description
    51  *
    52  * For more see usb hub specification in 11.15.1 of
    53  */
    54 extern usb_endpoint_description_t hub_status_change_endpoint_description;
    55 
    56 
    57 
    58 /* Hub endpoints. */
    59 /*typedef struct {
    60         usb_endpoint_pipe_t control;
    61         usb_endpoint_pipe_t status_change;
    62 } usb_hub_endpoints_t;
    63 */
    64 
    65 
    6650/** Information about attached hub. */
    6751typedef struct {
    … …  
    8872         * searched again and again for the 'right pipe'.
    8973         */
    90         usb_endpoint_pipe_t * status_change_pipe;
     74        usb_pipe_t * status_change_pipe;
    9175
    9276        /** convenience pointer to control pipe
    … …  
    9680         * searched again and again for the 'right pipe'.
    9781         */
    98         usb_endpoint_pipe_t * control_pipe;
     82        usb_pipe_t * control_pipe;
    9983
    10084        /** generic usb device data*/

  • uspace/drv/usbhub/usbhub_private.h

    rfd9f6e4c r41ef5b9  
    9595 * @return Operation result
    9696 */
    97 static inline int usb_hub_clear_port_feature(usb_endpoint_pipe_t *pipe,
     97static inline int usb_hub_clear_port_feature(usb_pipe_t *pipe,
    9898    int port_index,
    9999    usb_hub_class_feature_t feature) {
    … …  
    106106        };
    107107        clear_request.value = feature;
    108         return usb_endpoint_pipe_control_write(pipe, &clear_request,
     108        return usb_pipe_control_write(pipe, &clear_request,
    109109            sizeof(clear_request), NULL, 0);
    110110}

  • uspace/drv/usbmid/main.c

    rfd9f6e4c r41ef5b9  
    6161        int rc;
    6262
    63         rc = usb_endpoint_pipe_start_session(&dev->ctrl_pipe);
     63        rc = usb_pipe_start_session(&dev->ctrl_pipe);
    6464        if (rc != EOK) {
    6565                usb_log_error("Failed to start session on control pipe: %s.\n",
    … …  
    7070        bool accept = usbmid_explore_device(dev);
    7171
    72         rc = usb_endpoint_pipe_end_session(&dev->ctrl_pipe);
     72        rc = usb_pipe_end_session(&dev->ctrl_pipe);
    7373        if (rc != EOK) {
    7474                usb_log_warning("Failed to end session on control pipe: %s.\n",

  • uspace/drv/usbmid/usbmid.c

    rfd9f6e4c r41ef5b9  
    108108        }
    109109
    110         rc = usb_endpoint_pipe_initialize_default_control(&mid->ctrl_pipe,
     110        rc = usb_pipe_initialize_default_control(&mid->ctrl_pipe,
    111111            &mid->wire);
    112112        if (rc != EOK) {
    … …  
    116116                return NULL;
    117117        }
    118         rc = usb_endpoint_pipe_probe_default_control(&mid->ctrl_pipe);
     118        rc = usb_pipe_probe_default_control(&mid->ctrl_pipe);
    119119        if (rc != EOK) {
    120120                usb_log_error("Probing default control pipe failed: %s.\n",

  • uspace/drv/usbmid/usbmid.h

    rfd9f6e4c r41ef5b9  
    5252        usb_device_connection_t wire;
    5353        /** Default control pipe. */
    54         usb_endpoint_pipe_t ctrl_pipe;
     54        usb_pipe_t ctrl_pipe;
    5555} usbmid_device_t;
    5656

  • uspace/drv/usbmouse/init.c

    rfd9f6e4c r41ef5b9  
    126126       
    127127        /* Open the control pipe. */
    128         rc = usb_endpoint_pipe_start_session(&dev->ctrl_pipe);
     128        rc = usb_pipe_start_session(&dev->ctrl_pipe);
    129129        if (rc != EOK) {
    130130                goto leave;
    … …  
    141141       
    142142        /* Close the control pipe (ignore errors). */
    143         usb_endpoint_pipe_end_session(&dev->ctrl_pipe);
     143        usb_pipe_end_session(&dev->ctrl_pipe);
    144144
    145145

  • uspace/lib/usb/Makefile

    rfd9f6e4c r41ef5b9  
    4949        src/request.c \
    5050        src/usb.c \
    51         src/usbdevice.c
     51        src/usbdevice.c \
     52        src/host/device_keeper.c \
     53        src/host/batch.c
    5254
    5355include $(USPACE_PREFIX)/Makefile.common

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

    rfd9f6e4c r41ef5b9  
    6060} usb_hub_class_feature_t;
    6161
     62/** Header of standard hub descriptor without the "variadic" part. */
     63typedef struct {
     64        /** Descriptor length. */
     65        uint8_t length;
     66        /** Descriptor type (0x29). */
     67        uint8_t descriptor_type;
     68        /** Number of downstream ports. */
     69        uint8_t port_count;
     70        /** Characteristics bitmask. */
     71        uint16_t characteristics;
     72        /** Time from power-on to stabilization of current on the port. */
     73        uint8_t power_good_time;
     74        /** Maximum current requirements in mA. */
     75        uint8_t max_current;
     76} __attribute__ ((packed)) usb_hub_descriptor_header_t;
    6277
    6378/**

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

    rfd9f6e4c r41ef5b9  
    3838#include <usb/pipes.h>
    3939
     40/** Descriptors for USB device. */
     41typedef struct {
     42        /** Standard device descriptor. */
     43        usb_standard_device_descriptor_t device;
     44        /** Full configuration descriptor of current configuration. */
     45        uint8_t *configuration;
     46        size_t configuration_size;
     47} usb_device_descriptors_t;
     48
    4049/** USB device structure. */
    4150typedef struct {
    4251        /** The default control pipe. */
    43         usb_endpoint_pipe_t ctrl_pipe;
     52        usb_pipe_t ctrl_pipe;
    4453        /** Other endpoint pipes.
    4554         * This is an array of other endpoint pipes in the same order as
    … …  
    5261         */
    5362        int interface_no;
     63
     64        /** Some useful descriptors. */
     65        usb_device_descriptors_t descriptors;
     66
    5467        /** Generic DDF device backing this one. */
    5568        ddf_dev_t *ddf_dev;

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

    rfd9f6e4c r41ef5b9  
    2727 */
    2828
    29 /** @addtogroup drvusbuhcihc
     29/** @addtogroup libusb
    3030 * @{
    3131 */
    3232/** @file
    33  * @brief UHCI driver
     33 * Device keeper structure and functions.
     34 *
     35 * Typical USB host controller needs to keep track of various settings for
     36 * each device that is connected to it.
     37 * State of toggle bit, device speed etc. etc.
     38 * This structure shall simplify the management.
    3439 */
    35 #ifndef UTILS_DEVICE_KEEPER_H
    36 #define UTILS_DEVICE_KEEPER_H
     40#ifndef LIBUSB_HOST_DEVICE_KEEPER_H
     41#define LIBUSB_HOST_DEVICE_KEEPER_H
    3742#include <devman.h>
    3843#include <fibril_synch.h>
    3944#include <usb/usb.h>
    4045
     46/** Number of USB address for array dimensions. */
    4147#define USB_ADDRESS_COUNT (USB11_ADDRESS_MAX + 1)
    4248
     49/** Information about attached USB device. */
    4350struct usb_device_info {
    4451        usb_speed_t speed;
    4552        bool occupied;
    46         uint16_t toggle_status;
     53        uint16_t toggle_status[2];
    4754        devman_handle_t handle;
    4855};
    4956
    50 typedef struct device_keeper {
     57/** Host controller device keeper.
     58 * You shall not access members directly but only using functions below.
     59 */
     60typedef struct {
    5161        struct usb_device_info devices[USB_ADDRESS_COUNT];
    5262        fibril_mutex_t guard;
    5363        fibril_condvar_t default_address_occupied;
    5464        usb_address_t last_address;
    55 } device_keeper_t;
     65} usb_device_keeper_t;
    5666
    57 void device_keeper_init(device_keeper_t *instance);
     67void usb_device_keeper_init(usb_device_keeper_t *instance);
    5868
    59 void device_keeper_reserve_default(
    60     device_keeper_t *instance, usb_speed_t speed);
     69void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance,
     70    usb_speed_t speed);
    6171
    62 void device_keeper_release_default(device_keeper_t *instance);
     72void usb_device_keeper_release_default_address(usb_device_keeper_t *instance);
    6373
    64 void device_keeper_reset_if_need(
    65     device_keeper_t *instance, usb_target_t target, const unsigned char *setup_data);
     74void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
     75    usb_target_t target,
     76    const uint8_t *setup_data);
    6677
    67 int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target);
     78int usb_device_keeper_get_toggle(usb_device_keeper_t *instance,
     79    usb_target_t target, usb_direction_t direction);
    6880
    69 int device_keeper_set_toggle(
    70     device_keeper_t *instance, usb_target_t target, bool toggle);
     81int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
     82    usb_target_t target, usb_direction_t direction, bool toggle);
    7183
    72 usb_address_t device_keeper_request(
    73     device_keeper_t *instance, usb_speed_t speed);
     84usb_address_t device_keeper_get_free_address(usb_device_keeper_t *instance,
     85    usb_speed_t speed);
    7486
    75 void device_keeper_bind(
    76     device_keeper_t *instance, usb_address_t address, devman_handle_t handle);
     87void usb_device_keeper_bind(usb_device_keeper_t *instance,
     88    usb_address_t address, devman_handle_t handle);
    7789
    78 void device_keeper_release(device_keeper_t *instance, usb_address_t address);
     90void usb_device_keeper_release(usb_device_keeper_t *instance,
     91    usb_address_t address);
    7992
    80 usb_address_t device_keeper_find(
    81     device_keeper_t *instance, devman_handle_t handle);
     93usb_address_t usb_device_keeper_find(usb_device_keeper_t *instance,
     94    devman_handle_t handle);
    8295
    83 usb_speed_t device_keeper_speed(
    84     device_keeper_t *instance, usb_address_t address);
     96usb_speed_t usb_device_keeper_get_speed(usb_device_keeper_t *instance,
     97    usb_address_t address);
     98
    8599#endif
    86100/**

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

    rfd9f6e4c r41ef5b9  
    8080         */
    8181        int hc_phone;
    82 } usb_endpoint_pipe_t;
     82} usb_pipe_t;
    8383
    8484
    … …  
    102102typedef struct {
    103103        /** Endpoint pipe. */
    104         usb_endpoint_pipe_t *pipe;
     104        usb_pipe_t *pipe;
    105105        /** Endpoint description. */
    106106        const usb_endpoint_description_t *description;
    … …  
    125125usb_address_t usb_device_get_assigned_address(devman_handle_t);
    126126
    127 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *,
    128     usb_device_connection_t *,
     127int usb_pipe_initialize(usb_pipe_t *, usb_device_connection_t *,
    129128    usb_endpoint_t, usb_transfer_type_t, size_t, usb_direction_t);
    130 int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *,
     129int usb_pipe_initialize_default_control(usb_pipe_t *,
    131130    usb_device_connection_t *);
    132 int usb_endpoint_pipe_probe_default_control(usb_endpoint_pipe_t *);
    133 int usb_endpoint_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
     131int usb_pipe_probe_default_control(usb_pipe_t *);
     132int usb_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
    134133    size_t, uint8_t *, size_t, usb_device_connection_t *);
    135 int usb_endpoint_pipe_register(usb_endpoint_pipe_t *, unsigned int,
    136     usb_hc_connection_t *);
    137 int usb_endpoint_pipe_unregister(usb_endpoint_pipe_t *, usb_hc_connection_t *);
     134int usb_pipe_register(usb_pipe_t *, unsigned int, usb_hc_connection_t *);
     135int usb_pipe_unregister(usb_pipe_t *, usb_hc_connection_t *);
    138136
    139 int usb_endpoint_pipe_start_session(usb_endpoint_pipe_t *);
    140 int usb_endpoint_pipe_end_session(usb_endpoint_pipe_t *);
    141 bool usb_endpoint_pipe_is_session_started(usb_endpoint_pipe_t *);
     137int usb_pipe_start_session(usb_pipe_t *);
     138int usb_pipe_end_session(usb_pipe_t *);
     139bool usb_pipe_is_session_started(usb_pipe_t *);
    142140
    143 int usb_endpoint_pipe_read(usb_endpoint_pipe_t *, void *, size_t, size_t *);
    144 int usb_endpoint_pipe_write(usb_endpoint_pipe_t *, void *, size_t);
     141int usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);
     142int usb_pipe_write(usb_pipe_t *, void *, size_t);
    145143
    146 int usb_endpoint_pipe_control_read(usb_endpoint_pipe_t *, void *, size_t,
     144int usb_pipe_control_read(usb_pipe_t *, void *, size_t,
    147145    void *, size_t, size_t *);
    148 int usb_endpoint_pipe_control_write(usb_endpoint_pipe_t *, void *, size_t,
     146int usb_pipe_control_write(usb_pipe_t *, void *, size_t,
    149147    void *, size_t);
    150148

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

    rfd9f6e4c r41ef5b9  
    4848    const usb_standard_interface_descriptor_t *, match_id_list_t *);
    4949
    50 int usb_device_create_match_ids(usb_endpoint_pipe_t *, match_id_list_t *);
     50int usb_device_create_match_ids(usb_pipe_t *, match_id_list_t *);
    5151
    5252int usb_device_register_child_in_devman(usb_address_t, devman_handle_t,

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

    rfd9f6e4c r41ef5b9  
    8686} __attribute__ ((packed)) usb_device_request_setup_packet_t;
    8787
    88 int usb_control_request_set(usb_endpoint_pipe_t *,
     88int usb_control_request_set(usb_pipe_t *,
    8989    usb_request_type_t, usb_request_recipient_t, uint8_t,
    9090    uint16_t, uint16_t, void *, size_t);
    9191
    92 int usb_control_request_get(usb_endpoint_pipe_t *,
     92int usb_control_request_get(usb_pipe_t *,
    9393    usb_request_type_t, usb_request_recipient_t, uint8_t,
    9494    uint16_t, uint16_t, void *, size_t, size_t *);
    9595
    96 int usb_request_set_address(usb_endpoint_pipe_t *, usb_address_t);
    97 int usb_request_get_descriptor(usb_endpoint_pipe_t *, usb_request_type_t,
     96int usb_request_get_status(usb_pipe_t *, usb_request_recipient_t,
     97    uint16_t, uint16_t *);
     98int usb_request_clear_feature(usb_pipe_t *, usb_request_type_t,
     99    usb_request_recipient_t, uint16_t, uint16_t);
     100int usb_request_set_feature(usb_pipe_t *, usb_request_type_t,
     101    usb_request_recipient_t, uint16_t, uint16_t);
     102int usb_request_set_address(usb_pipe_t *, usb_address_t);
     103int usb_request_get_descriptor(usb_pipe_t *, usb_request_type_t,
    98104    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t,
    99105    size_t *);
    100 int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t *, usb_request_type_t,
     106int usb_request_get_descriptor_alloc(usb_pipe_t *, usb_request_type_t,
    101107    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void **, size_t *);
    102 int usb_request_get_device_descriptor(usb_endpoint_pipe_t *,
     108int usb_request_get_device_descriptor(usb_pipe_t *,
    103109    usb_standard_device_descriptor_t *);
    104 int usb_request_get_bare_configuration_descriptor(usb_endpoint_pipe_t *, int,
     110int usb_request_get_bare_configuration_descriptor(usb_pipe_t *, int,
    105111    usb_standard_configuration_descriptor_t *);
    106 int usb_request_get_full_configuration_descriptor(usb_endpoint_pipe_t *, int,
     112int usb_request_get_full_configuration_descriptor(usb_pipe_t *, int,
    107113    void *, size_t, size_t *);
    108 int usb_request_get_full_configuration_descriptor_alloc(usb_endpoint_pipe_t *,
     114int usb_request_get_full_configuration_descriptor_alloc(usb_pipe_t *,
    109115    int, void **, size_t *);
    110 int usb_request_set_configuration(usb_endpoint_pipe_t *, uint8_t);
     116int usb_request_set_descriptor(usb_pipe_t *, usb_request_type_t,
     117    usb_request_recipient_t, uint8_t, uint8_t, uint16_t, void *, size_t);
     118int usb_request_get_configuration(usb_pipe_t *, uint8_t *);
     119int usb_request_set_configuration(usb_pipe_t *, uint8_t);
     120int usb_request_get_interface(usb_pipe_t *, uint8_t, uint8_t *);
     121int usb_request_set_interface(usb_pipe_t *, uint8_t, uint8_t);
    111122
    112 int usb_request_get_supported_languages(usb_endpoint_pipe_t *,
     123int usb_request_get_supported_languages(usb_pipe_t *,
    113124    l18_win_locales_t **, size_t *);
    114 int usb_request_get_string(usb_endpoint_pipe_t *, size_t, l18_win_locales_t,
     125int usb_request_get_string(usb_pipe_t *, size_t, l18_win_locales_t,
    115126    char **);
    116127

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

    rfd9f6e4c r41ef5b9  
    6161
    6262const char * usb_str_transfer_type(usb_transfer_type_t t);
     63const char * usb_str_transfer_type_short(usb_transfer_type_t t);
    6364
    6465/** USB data transfer direction. */
    … …  
    7879        USB_SPEED_HIGH
    7980} usb_speed_t;
     81
     82const char *usb_str_speed(usb_speed_t);
     83
    8084
    8185/** USB request type target. */

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

    rfd9f6e4c r41ef5b9  
    126126
    127127        for (i = 0; i < pipe_count; i++) {
    128                 dev->pipes[i].pipe = malloc(sizeof(usb_endpoint_pipe_t));
     128                dev->pipes[i].pipe = malloc(sizeof(usb_pipe_t));
    129129                if (dev->pipes[i].pipe == NULL) {
    130130                        usb_log_oom(dev->ddf_dev);
    … …  
    137137        }
    138138
    139         void *config_descriptor;
    140         size_t config_descriptor_size;
    141         rc = usb_request_get_full_configuration_descriptor_alloc(
    142             &dev->ctrl_pipe, 0, &config_descriptor, &config_descriptor_size);
    143         if (rc != EOK) {
    144                 usb_log_error("Failed retrieving configuration of `%s': %s.\n",
    145                     dev->ddf_dev->name, str_error(rc));
    146                 goto rollback;
    147         }
    148 
    149         rc = usb_endpoint_pipe_initialize_from_configuration(dev->pipes,
    150            pipe_count, config_descriptor, config_descriptor_size, &dev->wire);
     139        rc = usb_pipe_initialize_from_configuration(dev->pipes, pipe_count,
     140            dev->descriptors.configuration, dev->descriptors.configuration_size,
     141            &dev->wire);
    151142        if (rc != EOK) {
    152143                usb_log_error("Failed initializing USB endpoints: %s.\n",
    … …  
    172163        for (i = 0; i < pipe_count; i++) {
    173164                if (dev->pipes[i].present) {
    174                         rc = usb_endpoint_pipe_register(dev->pipes[i].pipe,
     165                        rc = usb_pipe_register(dev->pipes[i].pipe,
    175166                            dev->pipes[i].descriptor->poll_interval,
    176167                            &hc_conn);
    … …  
    219210        }
    220211
    221         rc = usb_endpoint_pipe_initialize_default_control(&dev->ctrl_pipe,
     212        rc = usb_pipe_initialize_default_control(&dev->ctrl_pipe,
    222213            &dev->wire);
    223214        if (rc != EOK) {
    … …  
    228219        }
    229220
    230         rc = usb_endpoint_pipe_probe_default_control(&dev->ctrl_pipe);
     221        rc = usb_pipe_probe_default_control(&dev->ctrl_pipe);
    231222        if (rc != EOK) {
    232223                usb_log_error(
    … …  
    237228
    238229        /*
    239          * Initialization of other pipes requires open session on
    240          * default control pipe.
     230         * For further actions, we need open session on default control pipe.
    241231         */
    242         rc = usb_endpoint_pipe_start_session(&dev->ctrl_pipe);
     232        rc = usb_pipe_start_session(&dev->ctrl_pipe);
    243233        if (rc != EOK) {
    244234                usb_log_error("Failed to start an IPC session: %s.\n",
    245235                    str_error(rc));
     236                return rc;
     237        }
     238
     239        /* Get the device descriptor. */
     240        rc = usb_request_get_device_descriptor(&dev->ctrl_pipe,
     241            &dev->descriptors.device);
     242        if (rc != EOK) {
     243                usb_log_error("Failed to retrieve device descriptor: %s.\n",
     244                    str_error(rc));
     245                return rc;
     246        }
     247
     248        /* Get the full configuration descriptor. */
     249        rc = usb_request_get_full_configuration_descriptor_alloc(
     250            &dev->ctrl_pipe, 0, (void **) &dev->descriptors.configuration,
     251            &dev->descriptors.configuration_size);
     252        if (rc != EOK) {
     253                usb_log_error("Failed retrieving configuration descriptor: %s.\n",
     254                    dev->ddf_dev->name, str_error(rc));
    246255                return rc;
    247256        }
    … …  
    252261
    253262        /* No checking here. */
    254         usb_endpoint_pipe_end_session(&dev->ctrl_pipe);
     263        usb_pipe_end_session(&dev->ctrl_pipe);
     264
     265        /* Rollback actions. */
     266        if (rc != EOK) {
     267                if (dev->descriptors.configuration != NULL) {
     268                        free(dev->descriptors.configuration);
     269                }
     270        }
    255271
    256272        return rc;
    … …  
    283299        dev->ddf_dev->driver_data = dev;
    284300        dev->driver_data = NULL;
     301        dev->descriptors.configuration = NULL;
    285302
    286303        rc = initialize_pipes(dev);

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

    rfd9f6e4c r41ef5b9  
    6464        assert(polling_data);
    6565
    66         usb_endpoint_pipe_t *pipe
     66        usb_pipe_t *pipe
    6767            = polling_data->dev->pipes[polling_data->pipe_index].pipe;
    6868
    … …  
    7171                int rc;
    7272
    73                 rc = usb_endpoint_pipe_start_session(pipe);
     73                rc = usb_pipe_start_session(pipe);
    7474                if (rc != EOK) {
    7575                        failed_attempts++;
    … …  
    7878
    7979                size_t actual_size;
    80                 rc = usb_endpoint_pipe_read(pipe, polling_data->buffer,
     80                rc = usb_pipe_read(pipe, polling_data->buffer,
    8181                    polling_data->request_size, &actual_size);
    8282
    8383                /* Quit the session regardless of errors. */
    84                 usb_endpoint_pipe_end_session(pipe);
     84                usb_pipe_end_session(pipe);
    8585
    8686                if (rc != EOK) {

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

    rfd9f6e4c r41ef5b9  
    2727 */
    2828
    29 /** @addtogroup drvusbuhcihc
     29/** @addtogroup libusb
    3030 * @{
    3131 */
    3232/** @file
    33  * @brief UHCI driver
     33 * Device keeper structure and functions (implementation).
    3434 */
    3535#include <assert.h>
    3636#include <errno.h>
    3737#include <usb/debug.h>
    38 
    39 #include "device_keeper.h"
     38#include <usb/host/device_keeper.h>
    4039
    4140/*----------------------------------------------------------------------------*/
    … …  
    4645 * Set all values to false/0.
    4746 */
    48 void device_keeper_init(device_keeper_t *instance)
     47void usb_device_keeper_init(usb_device_keeper_t *instance)
    4948{
    5049        assert(instance);
    … …  
    5655                instance->devices[i].occupied = false;
    5756                instance->devices[i].handle = 0;
    58                 instance->devices[i].toggle_status = 0;
     57                instance->devices[i].toggle_status[0] = 0;
     58                instance->devices[i].toggle_status[1] = 0;
    5959        }
    6060}
    … …  
    6565 * @param[in] speed Speed of the device requesting default address.
    6666 */
    67 void device_keeper_reserve_default(device_keeper_t *instance, usb_speed_t speed)
     67void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance,
     68    usb_speed_t speed)
    6869{
    6970        assert(instance);
    … …  
    8384 * @param[in] speed Speed of the device requesting default address.
    8485 */
    85 void device_keeper_release_default(device_keeper_t *instance)
     86void usb_device_keeper_release_default_address(usb_device_keeper_t *instance)
    8687{
    8788        assert(instance);
    … …  
    100101 * Really ugly one.
    101102 */
    102 void device_keeper_reset_if_need(
    103     device_keeper_t *instance, usb_target_t target, const unsigned char *data)
     103void usb_device_keeper_reset_if_need(usb_device_keeper_t *instance,
     104    usb_target_t target, const uint8_t *data)
    104105{
    105106        assert(instance);
    … …  
    119120                if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
    120121                        /* endpoint number is < 16, thus first byte is enough */
    121                         instance->devices[target.address].toggle_status &=
     122                        instance->devices[target.address].toggle_status[0] &=
     123                            ~(1 << data[4]);
     124                        instance->devices[target.address].toggle_status[1] &=
    122125                            ~(1 << data[4]);
    123126                }
    … …  
    128131                /* target must be device */
    129132                if ((data[0] & 0xf) == 0) {
    130                         instance->devices[target.address].toggle_status = 0;
     133                        instance->devices[target.address].toggle_status[0] = 0;
     134                        instance->devices[target.address].toggle_status[1] = 0;
    131135                }
    132136        break;
    … …  
    141145 * @return Error code
    142146 */
    143 int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target)
    144 {
    145         assert(instance);
     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;
    146154        int ret;
    147155        fibril_mutex_lock(&instance->guard);
    … …  
    152160                ret = EINVAL;
    153161        } else {
    154                 ret = (instance->devices[target.address].toggle_status
     162                ret = (instance->devices[target.address].toggle_status[direction]
    155163                        >> target.endpoint) & 1;
    156164        }
    … …  
    166174 * @return Error code.
    167175 */
    168 int device_keeper_set_toggle(
    169     device_keeper_t *instance, usb_target_t target, bool toggle)
    170 {
    171         assert(instance);
     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;
    172183        int ret;
    173184        fibril_mutex_lock(&instance->guard);
    … …  
    179190        } else {
    180191                if (toggle) {
    181                         instance->devices[target.address].toggle_status |= (1 << target.endpoint);
     192                        instance->devices[target.address].toggle_status[direction]
     193                            |= (1 << target.endpoint);
    182194                } else {
    183                         instance->devices[target.address].toggle_status &= ~(1 << target.endpoint);
     195                        instance->devices[target.address].toggle_status[direction]
     196                            &= ~(1 << target.endpoint);
    184197                }
    185198                ret = EOK;
    … …  
    195208 * @return Free address, or error code.
    196209 */
    197 usb_address_t device_keeper_request(
    198     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)
    199212{
    200213        assert(instance);
    … …  
    216229        instance->devices[new_address].occupied = true;
    217230        instance->devices[new_address].speed = speed;
    218         instance->devices[new_address].toggle_status = 0;
     231        instance->devices[new_address].toggle_status[0] = 0;
     232        instance->devices[new_address].toggle_status[1] = 0;
    219233        instance->last_address = new_address;
    220234        fibril_mutex_unlock(&instance->guard);
    … …  
    228242 * @param[in] handle Devman handle of the device.
    229243 */
    230 void device_keeper_bind(
    231     device_keeper_t *instance, usb_address_t address, devman_handle_t handle)
     244void usb_device_keeper_bind(usb_device_keeper_t *instance,
     245    usb_address_t address, devman_handle_t handle)
    232246{
    233247        assert(instance);
    … …  
    245259 * @param[in] address Device address
    246260 */
    247 void device_keeper_release(device_keeper_t *instance, usb_address_t address)
     261void usb_device_keeper_release(usb_device_keeper_t *instance,
     262    usb_address_t address)
    248263{
    249264        assert(instance);
    … …  
    263278 * @return USB Address, or error code.
    264279 */
    265 usb_address_t device_keeper_find(
    266     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)
    267282{
    268283        assert(instance);
    … …  
    286301 * @return USB speed.
    287302 */
    288 usb_speed_t device_keeper_speed(
    289     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)
    290305{
    291306        assert(instance);
    … …  
    294309        return instance->devices[address].speed;
    295310}
     311
    296312/**
    297313 * @}

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

    rfd9f6e4c r41ef5b9  
    228228        }
    229229
    230         usb_endpoint_pipe_t ctrl_pipe;
    231         rc = usb_endpoint_pipe_initialize_default_control(&ctrl_pipe,
     230        usb_pipe_t ctrl_pipe;
     231        rc = usb_pipe_initialize_default_control(&ctrl_pipe,
    232232            &dev_conn);
    233233        if (rc != EOK) {
    … …  
    235235                goto leave_release_default_address;
    236236        }
    237         rc = usb_endpoint_pipe_probe_default_control(&ctrl_pipe);
     237        rc = usb_pipe_probe_default_control(&ctrl_pipe);
    238238        if (rc != EOK) {
    239239                rc = ENOTCONN;
    … …  
    241241        }
    242242
    243         rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
     243        rc = usb_pipe_start_session(&ctrl_pipe);
    244244        if (rc != EOK) {
    245245                rc = ENOTCONN;
    … …  
    253253        }
    254254
    255         usb_endpoint_pipe_end_session(&ctrl_pipe);
     255        usb_pipe_end_session(&ctrl_pipe);
    256256
    257257        /*
    … …  
    306306
    307307leave_stop_session:
    308         usb_endpoint_pipe_end_session(&ctrl_pipe);
     308        usb_pipe_end_session(&ctrl_pipe);
    309309
    310310leave_release_default_address:

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

    rfd9f6e4c r41ef5b9  
    4242#include <assert.h>
    4343
     44#define IPC_AGAIN_DELAY (1000 * 2) /* 2ms */
     45
    4446/** Tell USB address assigned to given device.
    4547 *
    … …  
    150152        }
    151153
    152         my_address = get_my_address(parent_phone, dev);
    153         if (my_address < 0) {
    154                 rc = my_address;
    155                 goto leave;
    156         }
     154        /*
     155         * Asking for "my" address may require several attempts.
     156         * That is because following scenario may happen:
     157         *  - parent driver (i.e. driver of parent device) announces new device
     158         *    and devman launches current driver
     159         *  - parent driver is preempted and thus does not send address-handle
     160         *    binding to HC driver
     161         *  - this driver gets here and wants the binding
     162         *  - the HC does not know the binding yet and thus it answers ENOENT
     163         *  So, we need to wait for the HC to learn the binding.
     164         */
     165        do {
     166                my_address = get_my_address(parent_phone, dev);
     167
     168                if (my_address == ENOENT) {
     169                        /* Be nice, let other fibrils run and try again. */
     170                        async_usleep(IPC_AGAIN_DELAY);
     171                } else if (my_address < 0) {
     172                        /* Some other problem, no sense trying again. */
     173                        rc = my_address;
     174                        goto leave;
     175                }
     176
     177        } while (my_address < 0);
    157178
    158179        rc = usb_device_connection_initialize(connection,
    … …  
    212233 * A session is something inside what any communication occurs.
    213234 * It is expected that sessions would be started right before the transfer
    214  * and ended - see usb_endpoint_pipe_end_session() - after the last
     235 * and ended - see usb_pipe_end_session() - after the last
    215236 * transfer.
    216237 * The reason for this is that session actually opens some communication
    … …  
    223244 * @return Error code.
    224245 */
    225 int usb_endpoint_pipe_start_session(usb_endpoint_pipe_t *pipe)
     246int usb_pipe_start_session(usb_pipe_t *pipe)
    226247{
    227248        assert(pipe);
    228249
    229         if (usb_endpoint_pipe_is_session_started(pipe)) {
     250        if (usb_pipe_is_session_started(pipe)) {
    230251                return EBUSY;
    231252        }
    … …  
    244265/** Ends a session on the endpoint pipe.
    245266 *
    246  * @see usb_endpoint_pipe_start_session
     267 * @see usb_pipe_start_session
    247268 *
    248269 * @param pipe Endpoint pipe to end the session on.
    249270 * @return Error code.
    250271 */
    251 int usb_endpoint_pipe_end_session(usb_endpoint_pipe_t *pipe)
     272int usb_pipe_end_session(usb_pipe_t *pipe)
    252273{
    253274        assert(pipe);
    254275
    255         if (!usb_endpoint_pipe_is_session_started(pipe)) {
     276        if (!usb_pipe_is_session_started(pipe)) {
    256277                return ENOENT;
    257278        }
    … …  
    275296 * @return Whether @p pipe has opened a session.
    276297 */
    277 bool usb_endpoint_pipe_is_session_started(usb_endpoint_pipe_t *pipe)
     298bool usb_pipe_is_session_started(usb_pipe_t *pipe)
    278299{
    279300        return (pipe->hc_phone >= 0);

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

    rfd9f6e4c r41ef5b9  
    193193        }
    194194
    195         int rc = usb_endpoint_pipe_initialize(ep_mapping->pipe, wire,
     195        int rc = usb_pipe_initialize(ep_mapping->pipe, wire,
    196196            ep_no, description.transfer_type, endpoint->max_packet_size,
    197197            description.direction);
    … …  
    276276 * @return Error code.
    277277 */
    278 int usb_endpoint_pipe_initialize_from_configuration(
     278int usb_pipe_initialize_from_configuration(
    279279    usb_endpoint_mapping_t *mapping, size_t mapping_count,
    280280    uint8_t *configuration_descriptor, size_t configuration_descriptor_size,
    … …  
    342342 * @return Error code.
    343343 */
    344 int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe,
     344int usb_pipe_initialize(usb_pipe_t *pipe,
    345345    usb_device_connection_t *connection, usb_endpoint_t endpoint_no,
    346346    usb_transfer_type_t transfer_type, size_t max_packet_size,
    … …  
    367367 * @return Error code.
    368368 */
    369 int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *pipe,
     369int usb_pipe_initialize_default_control(usb_pipe_t *pipe,
    370370    usb_device_connection_t *connection)
    371371{
    … …  
    373373        assert(connection);
    374374
    375         int rc = usb_endpoint_pipe_initialize(pipe, connection,
     375        int rc = usb_pipe_initialize(pipe, connection,
    376376            0, USB_TRANSFER_CONTROL, CTRL_PIPE_MIN_PACKET_SIZE,
    377377            USB_DIRECTION_BOTH);
    … …  
    390390 * @return Error code.
    391391 */
    392 int usb_endpoint_pipe_probe_default_control(usb_endpoint_pipe_t *pipe)
     392int usb_pipe_probe_default_control(usb_pipe_t *pipe)
    393393{
    394394        assert(pipe);
    … …  
    408408
    409409        TRY_LOOP(failed_attempts) {
    410                 rc = usb_endpoint_pipe_start_session(pipe);
     410                rc = usb_pipe_start_session(pipe);
    411411                if (rc == EOK) {
    412412                        break;
    … …  
    433433                }
    434434        }
    435         usb_endpoint_pipe_end_session(pipe);
     435        usb_pipe_end_session(pipe);
    436436        if (rc != EOK) {
    437437                return rc;
    … …  
    451451 * @return Error code.
    452452 */
    453 int usb_endpoint_pipe_register(usb_endpoint_pipe_t *pipe,
     453int usb_pipe_register(usb_pipe_t *pipe,
    454454    unsigned int interval,
    455455    usb_hc_connection_t *hc_connection)
    … …  
    479479 * @return Error code.
    480480 */
    481 int usb_endpoint_pipe_unregister(usb_endpoint_pipe_t *pipe,
     481int usb_pipe_unregister(usb_pipe_t *pipe,
    482482    usb_hc_connection_t *hc_connection)
    483483{

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

    rfd9f6e4c r41ef5b9  
    5858 * @return Error code.
    5959 */
    60 static int usb_endpoint_pipe_read_no_checks(usb_endpoint_pipe_t *pipe,
     60static int usb_pipe_read_no_checks(usb_pipe_t *pipe,
    6161    void *buffer, size_t size, size_t *size_transfered)
    6262{
    … …  
    140140 * @return Error code.
    141141 */
    142 int usb_endpoint_pipe_read(usb_endpoint_pipe_t *pipe,
     142int usb_pipe_read(usb_pipe_t *pipe,
    143143    void *buffer, size_t size, size_t *size_transfered)
    144144{
    … …  
    153153        }
    154154
    155         if (!usb_endpoint_pipe_is_session_started(pipe)) {
     155        if (!usb_pipe_is_session_started(pipe)) {
    156156                return EBADF;
    157157        }
    … …  
    168168        int rc;
    169169
    170         rc = usb_endpoint_pipe_read_no_checks(pipe, buffer, size, &act_size);
     170        rc = usb_pipe_read_no_checks(pipe, buffer, size, &act_size);
    171171        if (rc != EOK) {
    172172                return rc;
    … …  
    190190 * @return Error code.
    191191 */
    192 static int usb_endpoint_pipe_write_no_check(usb_endpoint_pipe_t *pipe,
     192static int usb_pipe_write_no_check(usb_pipe_t *pipe,
    193193    void *buffer, size_t size)
    194194{
    … …  
    247247 * @return Error code.
    248248 */
    249 int usb_endpoint_pipe_write(usb_endpoint_pipe_t *pipe,
     249int usb_pipe_write(usb_pipe_t *pipe,
    250250    void *buffer, size_t size)
    251251{
    … …  
    260260        }
    261261
    262         if (!usb_endpoint_pipe_is_session_started(pipe)) {
     262        if (!usb_pipe_is_session_started(pipe)) {
    263263                return EBADF;
    264264        }
    … …  
    272272        }
    273273
    274         int rc = usb_endpoint_pipe_write_no_check(pipe, buffer, size);
     274        int rc = usb_pipe_write_no_check(pipe, buffer, size);
    275275
    276276        return rc;
    … …  
    289289 * @return Error code.
    290290 */
    291 static int usb_endpoint_pipe_control_read_no_check(usb_endpoint_pipe_t *pipe,
     291static int usb_pipe_control_read_no_check(usb_pipe_t *pipe,
    292292    void *setup_buffer, size_t setup_buffer_size,
    293293    void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)
    … …  
    365365 * @return Error code.
    366366 */
    367 int usb_endpoint_pipe_control_read(usb_endpoint_pipe_t *pipe,
     367int usb_pipe_control_read(usb_pipe_t *pipe,
    368368    void *setup_buffer, size_t setup_buffer_size,
    369369    void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)
    … …  
    379379        }
    380380
    381         if (!usb_endpoint_pipe_is_session_started(pipe)) {
     381        if (!usb_pipe_is_session_started(pipe)) {
    382382                return EBADF;
    383383        }
    … …  
    389389
    390390        size_t act_size = 0;
    391         int rc = usb_endpoint_pipe_control_read_no_check(pipe,
     391        int rc = usb_pipe_control_read_no_check(pipe,
    392392            setup_buffer, setup_buffer_size,
    393393            data_buffer, data_buffer_size, &act_size);
    … …  
    414414 * @return Error code.
    415415 */
    416 static int usb_endpoint_pipe_control_write_no_check(usb_endpoint_pipe_t *pipe,
     416static int usb_pipe_control_write_no_check(usb_pipe_t *pipe,
    417417    void *setup_buffer, size_t setup_buffer_size,
    418418    void *data_buffer, size_t data_buffer_size)
    … …  
    473473 * @return Error code.
    474474 */
    475 int usb_endpoint_pipe_control_write(usb_endpoint_pipe_t *pipe,
     475int usb_pipe_control_write(usb_pipe_t *pipe,
    476476    void *setup_buffer, size_t setup_buffer_size,
    477477    void *data_buffer, size_t data_buffer_size)
    … …  
    491491        }
    492492
    493         if (!usb_endpoint_pipe_is_session_started(pipe)) {
     493        if (!usb_pipe_is_session_started(pipe)) {
    494494                return EBADF;
    495495        }
    … …  
    500500        }
    501501
    502         int rc = usb_endpoint_pipe_control_write_no_check(pipe,
     502        int rc = usb_pipe_control_write_no_check(pipe,
    503503            setup_buffer, setup_buffer_size, data_buffer, data_buffer_size);
    504504

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

    rfd9f6e4c r41ef5b9  
    247247#undef VENDOR_ONLY_FMT
    248248#undef VENDOR_ONLY_ARGS
     249
     250        /* As a last resort, try fallback driver. */
     251        ADD_MATCHID_OR_RETURN(matches, 10, "usb&interface&fallback");
    249252
    250253        return EOK;
    … …  
    291294        }
    292295       
     296        /* As a last resort, try fallback driver. */
     297        ADD_MATCHID_OR_RETURN(matches, 10, "usb&fallback");
     298
    293299        return EOK;
    294300}
    … …  
    305311 * @return Error code.
    306312 */
    307 int usb_device_create_match_ids(usb_endpoint_pipe_t *ctrl_pipe,
     313int usb_device_create_match_ids(usb_pipe_t *ctrl_pipe,
    308314    match_id_list_t *matches)
    309315{
    … …  
    357363        int rc;
    358364        usb_device_connection_t dev_connection;
    359         usb_endpoint_pipe_t ctrl_pipe;
     365        usb_pipe_t ctrl_pipe;
    360366
    361367        rc = usb_device_connection_initialize(&dev_connection, hc_handle, address);
    … …  
    364370        }
    365371
    366         rc = usb_endpoint_pipe_initialize_default_control(&ctrl_pipe,
     372        rc = usb_pipe_initialize_default_control(&ctrl_pipe,
    367373            &dev_connection);
    368374        if (rc != EOK) {
    369375                goto failure;
    370376        }
    371         rc = usb_endpoint_pipe_probe_default_control(&ctrl_pipe);
     377        rc = usb_pipe_probe_default_control(&ctrl_pipe);
    372378        if (rc != EOK) {
    373379                goto failure;
    … …  
    398404        child->driver_data = dev_data;
    399405
    400         rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
     406        rc = usb_pipe_start_session(&ctrl_pipe);
    401407        if (rc != EOK) {
    402408                goto failure;
    … …  
    408414        }
    409415
    410         rc = usb_endpoint_pipe_end_session(&ctrl_pipe);
     416        rc = usb_pipe_end_session(&ctrl_pipe);
    411417        if (rc != EOK) {
    412418                goto failure;

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

    rfd9f6e4c r41ef5b9  
    4242/** Generic wrapper for SET requests using standard control request format.
    4343 *
    44  * @see usb_endpoint_pipe_control_write
     44 * @see usb_pipe_control_write
    4545 *
    4646 * @param pipe Pipe used for the communication.
    … …  
    6060 * @retval ERANGE Data buffer too large.
    6161 */
    62 int usb_control_request_set(usb_endpoint_pipe_t *pipe,
     62int usb_control_request_set(usb_pipe_t *pipe,
    6363    usb_request_type_t request_type, usb_request_recipient_t recipient,
    6464    uint8_t request,
    … …  
    9090        setup_packet.length = (uint16_t) data_size;
    9191
    92         int rc = usb_endpoint_pipe_control_write(pipe,
     92        int rc = usb_pipe_control_write(pipe,
    9393            &setup_packet, sizeof(setup_packet),
    9494            data, data_size);
    … …  
    9999 /** Generic wrapper for GET requests using standard control request format.
    100100  *
    101   * @see usb_endpoint_pipe_control_read
     101  * @see usb_pipe_control_read
    102102  *
    103103  * @param pipe Pipe used for the communication.
    … …  
    120120  * @retval ERANGE Data buffer too large.
    121121  */
    122 int usb_control_request_get(usb_endpoint_pipe_t *pipe,
     122int usb_control_request_get(usb_pipe_t *pipe,
    123123    usb_request_type_t request_type, usb_request_recipient_t recipient,
    124124    uint8_t request,
    … …  
    150150        setup_packet.length = (uint16_t) data_size;
    151151
    152         int rc = usb_endpoint_pipe_control_read(pipe,
     152        int rc = usb_pipe_control_read(pipe,
    153153            &setup_packet, sizeof(setup_packet),
    154154            data, data_size, actual_data_size);
     155
     156        return rc;
     157}
     158
     159/** Retrieve status of a USB device.
     160 *
     161 * @param[in] pipe Control endpoint pipe (session must be already started).
     162 * @param[in] index Recipient index (in native endianness).
     163 * @param[in] recipient Recipient of the GET_STATUS request.
     164 * @param[out] status Recipient status (in native endianness).
     165 * @return Error code.
     166 */
     167int usb_request_get_status(usb_pipe_t *pipe,
     168    usb_request_recipient_t recipient, uint16_t index,
     169    uint16_t *status)
     170{
     171        if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) && (index != 0)) {
     172                return EINVAL;
     173        }
     174
     175        if (status == NULL) {
     176                return EBADMEM;
     177        }
     178
     179        uint16_t status_usb_endianess;
     180        size_t data_transfered_size;
     181        int rc = usb_control_request_get(pipe, USB_REQUEST_TYPE_STANDARD,
     182            recipient, USB_DEVREQ_GET_STATUS, 0, uint16_host2usb(index),
     183            &status_usb_endianess, 2, &data_transfered_size);
     184        if (rc != EOK) {
     185                return rc;
     186        }
     187        if (data_transfered_size != 2) {
     188                return ELIMIT;
     189        }
     190
     191        *status = uint16_usb2host(status_usb_endianess);
     192
     193        return EOK;
     194}
     195
     196/** Clear or disable specific device feature.
     197 *
     198 * @param[in] pipe Control endpoint pipe (session must be already started).
     199 * @param[in] request_type Request type (standard/class/vendor).
     200 * @param[in] recipient Recipient of the CLEAR_FEATURE request.
     201 * @param[in] feature_selector Feature selector (in native endianness).
     202 * @param[in] index Recipient index (in native endianness).
     203 * @return Error code.
     204 */
     205int usb_request_clear_feature(usb_pipe_t *pipe,
     206    usb_request_type_t request_type, usb_request_recipient_t recipient,
     207    uint16_t feature_selector, uint16_t index)
     208{
     209        if (request_type == USB_REQUEST_TYPE_STANDARD) {
     210                if ((recipient == USB_REQUEST_RECIPIENT_DEVICE)
     211                    && (index != 0)) {
     212                        return EINVAL;
     213                }
     214        }
     215
     216        int rc = usb_control_request_set(pipe, request_type, recipient,
     217            USB_DEVREQ_CLEAR_FEATURE,
     218            uint16_host2usb(feature_selector), uint16_host2usb(index),
     219            NULL, 0);
     220
     221        return rc;
     222}
     223
     224/** Set or enable specific device feature.
     225 *
     226 * @param[in] pipe Control endpoint pipe (session must be already started).
     227 * @param[in] request_type Request type (standard/class/vendor).
     228 * @param[in] recipient Recipient of the SET_FEATURE request.
     229 * @param[in] feature_selector Feature selector (in native endianness).
     230 * @param[in] index Recipient index (in native endianness).
     231 * @return Error code.
     232 */
     233int usb_request_set_feature(usb_pipe_t *pipe,
     234    usb_request_type_t request_type, usb_request_recipient_t recipient,
     235    uint16_t feature_selector, uint16_t index)
     236{
     237        if (request_type == USB_REQUEST_TYPE_STANDARD) {
     238                if ((recipient == USB_REQUEST_RECIPIENT_DEVICE)
     239                    && (index != 0)) {
     240                        return EINVAL;
     241                }
     242        }
     243
     244        int rc = usb_control_request_set(pipe, request_type, recipient,
     245            USB_DEVREQ_SET_FEATURE,
     246            uint16_host2usb(feature_selector), uint16_host2usb(index),
     247            NULL, 0);
    155248
    156249        return rc;
    … …  
    165258 * @return Error code.
    166259 */
    167 int usb_request_set_address(usb_endpoint_pipe_t *pipe,
     260int usb_request_set_address(usb_pipe_t *pipe,
    168261    usb_address_t new_address)
    169262{
    … …  
    204297 * @return Error code.
    205298 */
    206 int usb_request_get_descriptor(usb_endpoint_pipe_t *pipe,
     299int usb_request_get_descriptor(usb_pipe_t *pipe,
    207300    usb_request_type_t request_type, usb_request_recipient_t recipient,
    208301    uint8_t descriptor_type, uint8_t descriptor_index,
    … …  
    238331 * @return
    239332 */
    240 int usb_request_get_descriptor_alloc(usb_endpoint_pipe_t * pipe,
     333int usb_request_get_descriptor_alloc(usb_pipe_t * pipe,
    241334    usb_request_type_t request_type, usb_request_recipient_t recipient,
    242335    uint8_t descriptor_type, uint8_t descriptor_index,
    … …  
    307400 * @return Error code.
    308401 */
    309 int usb_request_get_device_descriptor(usb_endpoint_pipe_t *pipe,
     402int usb_request_get_device_descriptor(usb_pipe_t *pipe,
    310403    usb_standard_device_descriptor_t *descriptor)
    311404{
    … …  
    349442 * @return Error code.
    350443 */
    351 int usb_request_get_bare_configuration_descriptor(usb_endpoint_pipe_t *pipe,
     444int usb_request_get_bare_configuration_descriptor(usb_pipe_t *pipe,
    352445    int index, usb_standard_configuration_descriptor_t *descriptor)
    353446{
    … …  
    395488 * @return Error code.
    396489 */
    397 int usb_request_get_full_configuration_descriptor(usb_endpoint_pipe_t *pipe,
     490int usb_request_get_full_configuration_descriptor(usb_pipe_t *pipe,
    398491    int index, void *descriptor, size_t descriptor_size, size_t *actual_size)
    399492{
    … …  
    421514 */
    422515int usb_request_get_full_configuration_descriptor_alloc(
    423     usb_endpoint_pipe_t *pipe, int index,
     516    usb_pipe_t *pipe, int index,
    424517    void **descriptor_ptr, size_t *descriptor_size)
    425518{
    … …  
    473566}
    474567
     568/** Update existing or add new USB descriptor to a USB device.
     569 *
     570 * @param[in] pipe Control endpoint pipe (session must be already started).
     571 * @param[in] request_type Request type (standard/class/vendor).
     572 * @param[in] recipient Request recipient (device/interface/endpoint).
     573 * @param[in] descriptor_type Descriptor type (device/configuration/HID/...).
     574 * @param[in] descriptor_index Descriptor index.
     575 * @param[in] language Language index (in native endianness).
     576 * @param[in] buffer Buffer with the new descriptor (in USB endianness).
     577 * @param[in] size Size of the @p buffer in bytes (in native endianness).
     578 * @return Error code.
     579 */
     580int usb_request_set_descriptor(usb_pipe_t *pipe,
     581    usb_request_type_t request_type, usb_request_recipient_t recipient,
     582    uint8_t descriptor_type, uint8_t descriptor_index,
     583    uint16_t language,
     584    void *buffer, size_t size)
     585{
     586        if (buffer == NULL) {
     587                return EBADMEM;
     588        }
     589        if (size == 0) {
     590                return EINVAL;
     591        }
     592
     593        /* FIXME: proper endianness. */
     594        uint16_t wValue = descriptor_index | (descriptor_type << 8);
     595
     596        return usb_control_request_set(pipe,
     597            request_type, recipient,
     598            USB_DEVREQ_SET_DESCRIPTOR,
     599            wValue, language,
     600            buffer, size);
     601}
     602
     603/** Get current configuration value of USB device.
     604 *
     605 * @param[in] pipe Control endpoint pipe (session must be already started).
     606 * @param[out] configuration_value Current configuration value.
     607 * @return Error code.
     608 */
     609int usb_request_get_configuration(usb_pipe_t *pipe,
     610    uint8_t *configuration_value)
     611{
     612        uint8_t value;
     613        size_t actual_size;
     614
     615        int rc = usb_control_request_get(pipe,
     616            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE,
     617            USB_DEVREQ_GET_CONFIGURATION,
     618            0, 0,
     619            &value, 1, &actual_size);
     620
     621        if (rc != EOK) {
     622                return rc;
     623        }
     624        if (actual_size != 1) {
     625                return ELIMIT;
     626        }
     627
     628        if (configuration_value != NULL) {
     629                *configuration_value = value;
     630        }
     631
     632        return EOK;
     633}
     634
    475635/** Set configuration of USB device.
    476636 *
    … …  
    479639 * @return Error code.
    480640 */
    481 int usb_request_set_configuration(usb_endpoint_pipe_t *pipe,
     641int usb_request_set_configuration(usb_pipe_t *pipe,
    482642    uint8_t configuration_value)
    483643{
    … …  
    491651}
    492652
     653/** Get selected alternate setting for USB interface.
     654 *
     655 * @param[in] pipe Control endpoint pipe (session must be already started).
     656 * @param[in] interface_index Interface index.
     657 * @param[out] alternate_setting Alternate setting for the interface.
     658 * @return Error code.
     659 */
     660int usb_request_get_interface(usb_pipe_t *pipe,
     661    uint8_t interface_index, uint8_t *alternate_setting)
     662{
     663        uint8_t value;
     664        size_t actual_size;
     665
     666        int rc = usb_control_request_get(pipe,
     667            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE,
     668            USB_DEVREQ_GET_INTERFACE,
     669            0, uint16_host2usb((uint16_t) interface_index),
     670            &value, 1, &actual_size);
     671
     672        if (rc != EOK) {
     673                return rc;
     674        }
     675        if (actual_size != 1) {
     676                return ELIMIT;
     677        }
     678
     679        if (alternate_setting != NULL) {
     680                *alternate_setting = value;
     681        }
     682
     683        return EOK;
     684}
     685
     686/** Select alternate setting for USB interface.
     687 *
     688 * @param[in] pipe Control endpoint pipe (session must be already started).
     689 * @param[in] interface_index Interface index.
     690 * @param[in] alternate_setting Alternate setting to select.
     691 * @return Error code.
     692 */
     693int usb_request_set_interface(usb_pipe_t *pipe,
     694    uint8_t interface_index, uint8_t alternate_setting)
     695{
     696        return usb_control_request_set(pipe,
     697            USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE,
     698            USB_DEVREQ_SET_INTERFACE,
     699            uint16_host2usb((uint16_t) alternate_setting),
     700            uint16_host2usb((uint16_t) interface_index),
     701            NULL, 0);
     702}
     703
    493704/** Get list of supported languages by USB device.
    494705 *
    … …  
    499710 * @return Error code.
    500711 */
    501 int usb_request_get_supported_languages(usb_endpoint_pipe_t *pipe,
     712int usb_request_get_supported_languages(usb_pipe_t *pipe,
    502713    l18_win_locales_t **languages_ptr, size_t *languages_count)
    503714{
    … …  
    571782 * @return Error code.
    572783 */
    573 int usb_request_get_string(usb_endpoint_pipe_t *pipe,
     784int usb_request_get_string(usb_pipe_t *pipe,
    574785    size_t index, l18_win_locales_t lang, char **string_ptr)
    575786{

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

    rfd9f6e4c r41ef5b9  
    3636#include <errno.h>
    3737
     38#define ARR_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
     39
     40static const char *str_speed[] = {
     41        "low",
     42        "full",
     43        "high"
     44};
     45
     46static const char *str_transfer_type[] = {
     47        "control",
     48        "isochronous",
     49        "bulk",
     50        "interrupt"
     51};
     52
     53static const char *str_transfer_type_short[] = {
     54        "ctrl",
     55        "iso",
     56        "bulk",
     57        "intr"
     58};
    3859
    3960/** String representation for USB transfer type.
    … …  
    4263 * @return Transfer type as a string (in English).
    4364 */
    44 const char * usb_str_transfer_type(usb_transfer_type_t t)
     65const char *usb_str_transfer_type(usb_transfer_type_t t)
    4566{
    46         switch (t) {
    47                 case USB_TRANSFER_ISOCHRONOUS:
    48                         return "isochronous";
    49                 case USB_TRANSFER_INTERRUPT:
    50                         return "interrupt";
    51                 case USB_TRANSFER_CONTROL:
    52                         return "control";
    53                 case USB_TRANSFER_BULK:
    54                         return "bulk";
    55                 default:
    56                         return "unknown";
     67        if (t >= ARR_SIZE(str_transfer_type)) {
     68                return "invalid";
    5769        }
     70        return str_transfer_type[t];
     71}
     72
     73/** String representation for USB transfer type (short version).
     74 *
     75 * @param t Transfer type.
     76 * @return Transfer type as a short string for debugging messages.
     77 */
     78const char *usb_str_transfer_type_short(usb_transfer_type_t t)
     79{
     80        if (t >= ARR_SIZE(str_transfer_type_short)) {
     81                return "invl";
     82        }
     83        return str_transfer_type_short[t];
     84}
     85
     86/** String representation of USB speed.
     87 *
     88 * @param s The speed.
     89 * @return USB speed as a string (in English).
     90 */
     91const char *usb_str_speed(usb_speed_t s)
     92{
     93        if (s >= ARR_SIZE(str_speed)) {
     94                return "invalid";
     95        }
     96        return str_speed[s];
    5897}
    5998
Note: See TracChangeset for help on using the changeset viewer.