Changes in / [d15809b4:0d36c20] in mainline


Ignore:
Location:
uspace
Files:
2 added
4 deleted
23 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/usbinfo/info.c

    rd15809b4 r0d36c20  
    3939#include <usb/usbdrv.h>
    4040#include <usb/pipes.h>
    41 #include <usb/recognise.h>
    4241#include <usb/request.h>
    4342#include "usbinfo.h"
    … …  
    4847        usb_device_connection_t wire;
    4948        usb_endpoint_pipe_t ctrl_pipe;
     49        ctrl_pipe.hc_phone = -1;
     50
     51        int hc_phone = devman_device_connect(hc_handle, 0);
     52        if (hc_phone < 0) {
     53                fprintf(stderr,
     54                    NAME ": failed to connect to host controller (%zu): %s.\n",
     55                        (size_t) hc_handle, str_error(hc_phone));
     56                return hc_phone;
     57        }
     58
     59        /*
     60         * Dump information about possible match ids.
     61         */
     62        match_id_list_t match_id_list;
     63        init_match_ids(&match_id_list);
     64        rc = usb_drv_create_device_match_ids(hc_phone, &match_id_list, address);
     65        if (rc != EOK) {
     66                fprintf(stderr,
     67                    NAME ": failed to fetch match ids of the device: %s.\n",
     68                    str_error(rc));
     69                goto leave;
     70        }
     71        dump_match_ids(&match_id_list);
    5072
    5173        /*
    … …  
    7395                goto leave;
    7496        }
    75 
    76         /*
    77          * Dump information about possible match ids.
    78          */
    79         match_id_list_t match_id_list;
    80         init_match_ids(&match_id_list);
    81         rc = usb_device_create_match_ids(&ctrl_pipe, &match_id_list);
    82         if (rc != EOK) {
    83                 fprintf(stderr,
    84                     NAME ": failed to fetch match ids of the device: %s.\n",
    85                     str_error(rc));
    86                 goto leave;
    87         }
    88         dump_match_ids(&match_id_list);
    8997
    9098        /*
    … …  
    133141leave:
    134142        /* Ignoring errors here. */
     143        async_hangup(hc_phone);
    135144        usb_endpoint_pipe_end_session(&ctrl_pipe);
    136145

  • uspace/app/usbinfo/main.c

    rd15809b4 r0d36c20  
    8181{
    8282        int rc;
    83 
    84         if (str_cmp(path, "uhci") == 0) {
    85                 path = "/hw/pci0/00:01.2";
    86         }
    8783
    8884        devman_handle_t handle;

  • uspace/drv/uhci-hcd/Makefile

    rd15809b4 r0d36c20  
    4040        uhci_struct/transfer_descriptor.c \
    4141        pci.c \
    42         batch.c
     42        tracker.c
    4343
    4444include $(USPACE_PREFIX)/Makefile.common

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

    rd15809b4 r0d36c20  
    109109        dev_speed_t speed = FULL_SPEED;
    110110
    111         batch_t *batch = batch_get(dev, target, USB_TRANSFER_INTERRUPT,
    112             max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
    113         if (!batch)
    114                 return ENOMEM;
    115         batch_interrupt_out(batch);
     111        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_INTERRUPT,
     112            max_packet_size, speed, data, size, NULL, callback, arg);
     113        if (!tracker)
     114                return ENOMEM;
     115        tracker_interrupt_out(tracker);
    116116        return EOK;
    117117}
    … …  
    124124        dev_speed_t speed = FULL_SPEED;
    125125
    126         batch_t *batch = batch_get(dev, target, USB_TRANSFER_INTERRUPT,
    127             max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
    128         if (!batch)
    129                 return ENOMEM;
    130         batch_interrupt_in(batch);
     126        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_INTERRUPT,
     127            max_packet_size, speed, data, size, callback, NULL, arg);
     128        if (!tracker)
     129                return ENOMEM;
     130        tracker_interrupt_in(tracker);
    131131        return EOK;
    132132}
    … …  
    139139        dev_speed_t speed = FULL_SPEED;
    140140
    141         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    142             max_packet_size, speed, data, size, setup_data, setup_size,
    143             NULL, callback, arg);
    144         if (!batch)
    145                 return ENOMEM;
    146         batch_control_write(batch);
     141        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     142            max_packet_size, speed, data, size, NULL, callback, arg);
     143        if (!tracker)
     144                return ENOMEM;
     145        tracker_control_write(tracker, setup_data, setup_size);
    147146        return EOK;
    148147}
    … …  
    155154        dev_speed_t speed = FULL_SPEED;
    156155
    157         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    158             max_packet_size, speed, data, size, setup_data, setup_size, callback,
    159             NULL, arg);
    160         if (!batch)
    161                 return ENOMEM;
    162         batch_control_read(batch);
     156        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     157            max_packet_size, speed, data, size, callback, NULL, arg);
     158        if (!tracker)
     159                return ENOMEM;
     160        tracker_control_read(tracker, setup_data, setup_size);
    163161        return EOK;
    164162}
    … …  
    168166    usbhc_iface_transfer_out_callback_t callback, void *arg)
    169167{
    170         size_t max_packet_size = 8;
    171         dev_speed_t speed = FULL_SPEED;
    172 
    173         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    174         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    175             max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
    176         if (!batch)
    177                 return ENOMEM;
    178         batch_control_setup_old(batch);
     168        usb_log_warning("Using deprecated API control write setup.\n");
     169        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     170            8, FULL_SPEED, data, size, NULL, callback, arg);
     171        if (!tracker)
     172                return ENOMEM;
     173        tracker_control_setup_old(tracker);
    179174        return EOK;
    180175}
    … …  
    184179    usbhc_iface_transfer_out_callback_t callback, void *arg)
    185180{
    186         size_t max_packet_size = 8;
    187         dev_speed_t speed = FULL_SPEED;
    188 
    189         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    190         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    191             max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
    192         if (!batch)
    193                 return ENOMEM;
    194         batch_control_write_data_old(batch);
     181        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     182            size, FULL_SPEED, data, size, NULL, callback, arg);
     183        if (!tracker)
     184                return ENOMEM;
     185        tracker_control_write_data_old(tracker);
    195186        return EOK;
    196187}
    … …  
    199190    usbhc_iface_transfer_in_callback_t callback, void *arg)
    200191{
    201         size_t max_packet_size = 8;
    202         dev_speed_t speed = FULL_SPEED;
    203 
    204         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    205         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    206             max_packet_size, speed, NULL, 0, NULL, 0, callback, NULL, arg);
    207         if (!batch)
    208                 return ENOMEM;
    209         batch_control_write_status_old(batch);
     192        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     193            0, FULL_SPEED, NULL, 0, callback, NULL, arg);
     194        if (!tracker)
     195                return ENOMEM;
     196        tracker_control_write_status_old(tracker);
    210197        return EOK;
    211198}
    … …  
    215202    usbhc_iface_transfer_out_callback_t callback, void *arg)
    216203{
    217         size_t max_packet_size = 8;
    218         dev_speed_t speed = FULL_SPEED;
    219 
    220         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    221         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    222             max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
    223         if (!batch)
    224                 return ENOMEM;
    225         batch_control_setup_old(batch);
     204        usb_log_warning("Using deprecated API control read setup.\n");
     205        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     206            8, FULL_SPEED, data, size, NULL, callback, arg);
     207        if (!tracker)
     208                return ENOMEM;
     209        tracker_control_setup_old(tracker);
    226210        return EOK;
    227211}
    … …  
    231215    usbhc_iface_transfer_in_callback_t callback, void *arg)
    232216{
    233         size_t max_packet_size = 8;
    234         dev_speed_t speed = FULL_SPEED;
    235 
    236         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    237         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    238             max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
    239         if (!batch)
    240                 return ENOMEM;
    241         batch_control_read_data_old(batch);
     217        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     218            size, FULL_SPEED, data, size, callback, NULL, arg);
     219        if (!tracker)
     220                return ENOMEM;
     221        tracker_control_read_data_old(tracker);
    242222        return EOK;
    243223}
    … …  
    246226    usbhc_iface_transfer_out_callback_t callback, void *arg)
    247227{
    248         size_t max_packet_size = 8;
    249         dev_speed_t speed = FULL_SPEED;
    250 
    251         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    252         batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    253             max_packet_size, speed, NULL, 0, NULL, 0, NULL, callback, arg);
    254         if (!batch)
    255                 return ENOMEM;
    256         batch_control_read_status_old(batch);
     228        tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     229            0, FULL_SPEED, NULL, 0, NULL, callback, arg);
     230        if (!tracker)
     231                return ENOMEM;
     232        tracker_control_read_status_old(tracker);
    257233        return EOK;
    258234}

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

    rd15809b4 r0d36c20  
    3535#include <errno.h>
    3636#include <stdio.h>
     37
    3738#include <usb_iface.h>
     39
    3840#include <usb/debug.h>
    3941
    4042#include "root_hub.h"
     43/*----------------------------------------------------------------------------*/
     44static int usb_iface_get_hc_handle(device_t *dev, devman_handle_t *handle)
     45{
     46  assert(dev);
     47  assert(dev->parent != NULL);
    4148
    42 extern device_ops_t child_ops;
     49  device_t *parent = dev->parent;
     50
     51  if (parent->ops && parent->ops->interfaces[USB_DEV_IFACE]) {
     52    usb_iface_t *usb_iface
     53        = (usb_iface_t *) parent->ops->interfaces[USB_DEV_IFACE];
     54    assert(usb_iface != NULL);
     55    if (usb_iface->get_hc_handle) {
     56      int rc = usb_iface->get_hc_handle(parent, handle);
     57      return rc;
     58    }
     59  }
     60
     61  return ENOTSUP;
     62}
    4363/*----------------------------------------------------------------------------*/
     64static usb_iface_t usb_iface = {
     65  .get_hc_handle = usb_iface_get_hc_handle
     66};
     67
     68static device_ops_t rh_ops = {
     69        .interfaces[USB_DEV_IFACE] = &usb_iface
     70};
     71
    4472int setup_root_hub(device_t **device, device_t *hc)
    4573{
    … …  
    80108        hub->name = name;
    81109        hub->parent = hc;
    82         hub->ops = &child_ops;
     110        hub->ops = &rh_ops;
    83111
    84112        *device = hub;

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

    rd15809b4 r0d36c20  
    5151
    5252        queue_head_init(instance->queue_head);
    53         list_initialize(&instance->batch_list);
    54         fibril_mutex_initialize(&instance->guard);
    5553        return EOK;
    5654}
    … …  
    6058        assert(instance);
    6159        assert(next);
     60        instance->next = next;
    6261        if (!instance->queue_head)
    6362                return;
    64         queue_head_append_qh(instance->queue_head, next->queue_head_pa);
    65         instance->queue_head->element = instance->queue_head->next_queue;
     63        queue_head_add_next(instance->queue_head, next->queue_head_pa);
    6664}
    6765/*----------------------------------------------------------------------------*/
    68 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch)
     66void transfer_list_add_tracker(transfer_list_t *instance, tracker_t *tracker)
    6967{
    7068        assert(instance);
    71         assert(batch);
     69        assert(tracker);
    7270
    73         uint32_t pa = (uintptr_t)addr_to_phys(batch->qh);
     71        uint32_t pa = (uintptr_t)addr_to_phys(tracker->td);
    7472        assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
    75         pa |= LINK_POINTER_QUEUE_HEAD_FLAG;
    7673
    77         batch->qh->next_queue = instance->queue_head->next_queue;
    7874
    79         fibril_mutex_lock(&instance->guard);
    80 
    81         if (instance->queue_head->element == instance->queue_head->next_queue) {
     75        if (instance->queue_head->element & LINK_POINTER_TERMINATE_FLAG) {
     76                usb_log_debug2("Adding td(%X:%X) to queue %s first.\n",
     77                        tracker->td->status, tracker->td->device, instance->name);
    8278                /* there is nothing scheduled */
    83                 list_append(&batch->link, &instance->batch_list);
     79                instance->last_tracker = tracker;
    8480                instance->queue_head->element = pa;
    85                 usb_log_debug2("Added batch(%p) to queue %s first.\n",
    86                         batch, instance->name);
    87                 fibril_mutex_unlock(&instance->guard);
     81                usb_log_debug2("Added td(%X:%X) to queue %s first.\n",
     82                        tracker->td->status, tracker->td->device, instance->name);
    8883                return;
    8984        }
    90         /* now we can be sure that there is someting scheduled */
    91         assert(!list_empty(&instance->batch_list));
    92         batch_t *first = list_get_instance(
    93                   instance->batch_list.next, batch_t, link);
    94         batch_t *last = list_get_instance(
    95             instance->batch_list.prev, batch_t, link);
    96         queue_head_append_qh(last->qh, pa);
    97         list_append(&batch->link, &instance->batch_list);
    98         usb_log_debug2("Added batch(%p) to queue %s last, first is %p.\n",
    99                 batch, instance->name, first );
    100         fibril_mutex_unlock(&instance->guard);
    101 }
    102 /*----------------------------------------------------------------------------*/
    103 static void transfer_list_remove_batch(
    104     transfer_list_t *instance, batch_t *batch)
    105 {
    106         assert(instance);
    107         assert(batch);
    108         assert(instance->queue_head);
    109         assert(batch->qh);
     85        usb_log_debug2("Adding td(%X:%X) to queue %s last.%p\n",
     86            tracker->td->status, tracker->td->device, instance->name,
     87            instance->last_tracker);
     88        /* now we can be sure that last_tracker is a valid pointer */
     89        instance->last_tracker->td->next = pa;
     90        instance->last_tracker = tracker;
    11091
    111         /* I'm the first one here */
    112         if (batch->link.prev == &instance->batch_list) {
    113                 usb_log_debug("Removing tracer %p was first, next element %x.\n",
    114                         batch, batch->qh->next_queue);
    115                 instance->queue_head->element = batch->qh->next_queue;
    116         } else {
    117                 usb_log_debug("Removing tracer %p was NOT first, next element %x.\n",
    118                         batch, batch->qh->next_queue);
    119                 batch_t *prev = list_get_instance(batch->link.prev, batch_t, link);
    120                 prev->qh->next_queue = batch->qh->next_queue;
     92        usb_log_debug2("Added td(%X:%X) to queue %s last.\n",
     93                tracker->td->status, tracker->td->device, instance->name);
     94
     95        /* check again, may be use atomic compare and swap */
     96        if (instance->queue_head->element & LINK_POINTER_TERMINATE_FLAG) {
     97                instance->queue_head->element = pa;
     98                usb_log_debug2("Added td(%X:%X) to queue first2 %s.\n",
     99                        tracker->td->status, tracker->td->device, instance->name);
    121100        }
    122         list_remove(&batch->link);
    123 }
    124 /*----------------------------------------------------------------------------*/
    125 void transfer_list_check(transfer_list_t *instance)
    126 {
    127         assert(instance);
    128         fibril_mutex_lock(&instance->guard);
    129         link_t *current = instance->batch_list.next;
    130         while (current != &instance->batch_list) {
    131                 link_t *next = current->next;
    132                 batch_t *batch = list_get_instance(current, batch_t, link);
    133 
    134                 if (batch_is_complete(batch)) {
    135                         transfer_list_remove_batch(instance, batch);
    136                         batch->next_step(batch);
    137                 }
    138                 current = next;
    139         }
    140         fibril_mutex_unlock(&instance->guard);
    141101}
    142102/**

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

    rd15809b4 r0d36c20  
    3535#define DRV_UHCI_TRANSFER_LIST_H
    3636
    37 #include <fibril_synch.h>
    38 
    3937#include "uhci_struct/queue_head.h"
    40 
    41 #include "batch.h"
     38#include "tracker.h"
    4239
    4340typedef struct transfer_list
    4441{
    45         fibril_mutex_t guard;
     42        tracker_t *last_tracker;
     43
    4644        queue_head_t *queue_head;
    4745        uint32_t queue_head_pa;
    4846        struct transfer_list *next;
    4947        const char *name;
    50         link_t batch_list;
    5148} transfer_list_t;
    5249
    … …  
    6057        queue_head_dispose(instance->queue_head);
    6158}
    62 void transfer_list_check(transfer_list_t *instance);
    6359
    64 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);
     60
     61void transfer_list_add_tracker(transfer_list_t *instance, tracker_t *tracker);
     62
    6563#endif
    6664/**

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

    rd15809b4 r0d36c20  
    8989        pio_write_32(&instance->registers->flbaseadd, (uint32_t)pa);
    9090
    91         list_initialize(&instance->batch_list);
    92         fibril_mutex_initialize(&instance->batch_list_mutex);
     91        list_initialize(&instance->tracker_list);
     92        fibril_mutex_initialize(&instance->tracker_list_mutex);
    9393
    9494        instance->cleaner = fibril_create(uhci_clean_finished, instance);
    … …  
    152152}
    153153/*----------------------------------------------------------------------------*/
    154 int uhci_schedule(uhci_t *instance, batch_t *batch)
     154int uhci_schedule(uhci_t *instance, tracker_t *tracker)
    155155{
    156156        assert(instance);
    157         assert(batch);
    158         const int low_speed = (batch->speed == LOW_SPEED);
     157        assert(tracker);
     158        const int low_speed = (tracker->speed == LOW_SPEED);
    159159        if (!allowed_usb_packet(
    160             low_speed, batch->transfer_type, batch->max_packet_size)) {
     160            low_speed, tracker->transfer_type, tracker->packet_size)) {
    161161                usb_log_warning("Invalid USB packet specified %s SPEED %d %zu.\n",
    162                           low_speed ? "LOW" : "FULL" , batch->transfer_type,
    163                     batch->max_packet_size);
     162                          low_speed ? "LOW" : "FULL" , tracker->transfer_type,
     163                    tracker->packet_size);
    164164                return ENOTSUP;
    165165        }
    166166        /* TODO: check available bandwith here */
    167167
     168        usb_log_debug2("Scheduler(%d) acquiring tracker list mutex.\n",
     169            fibril_get_id());
     170        fibril_mutex_lock(&instance->tracker_list_mutex);
     171        usb_log_debug2("Scheduler(%d) acquired tracker list mutex.\n",
     172            fibril_get_id());
     173
    168174        transfer_list_t *list =
    169             instance->transfers[low_speed][batch->transfer_type];
     175            instance->transfers[low_speed][tracker->transfer_type];
    170176        assert(list);
    171         transfer_list_add_batch(list, batch);
     177        transfer_list_add_tracker(list, tracker);
     178        list_append(&tracker->link, &instance->tracker_list);
     179
     180        usb_log_debug2("Scheduler(%d) releasing tracker list mutex.\n",
     181            fibril_get_id());
     182        fibril_mutex_unlock(&instance->tracker_list_mutex);
     183        usb_log_debug2("Scheduler(%d) released tracker list mutex.\n",
     184            fibril_get_id());
    172185
    173186        return EOK;
    … …  
    181194
    182195        while(1) {
    183                 transfer_list_check(&instance->transfers_interrupt);
    184                 transfer_list_check(&instance->transfers_control_slow);
    185                 transfer_list_check(&instance->transfers_control_full);
    186                 transfer_list_check(&instance->transfers_bulk_full);
     196                LIST_INITIALIZE(done_trackers);
     197                /* tracker iteration */
     198
     199                usb_log_debug2("Cleaner(%d) acquiring tracker list mutex.\n",
     200                    fibril_get_id());
     201                fibril_mutex_lock(&instance->tracker_list_mutex);
     202                usb_log_debug2("Cleaner(%d) acquired tracker list mutex.\n",
     203                    fibril_get_id());
     204
     205                link_t *current = instance->tracker_list.next;
     206                while (current != &instance->tracker_list)
     207                {
     208
     209                        link_t *next = current->next;
     210                        tracker_t *tracker = list_get_instance(current, tracker_t, link);
     211
     212                        assert(current == &tracker->link);
     213                        assert(tracker);
     214                        assert(tracker->next_step);
     215                        assert(tracker->td);
     216
     217                        if (!transfer_descriptor_is_active(tracker->td)) {
     218                                usb_log_info("Found inactive tracker with status: %x:%x.\n",
     219                                    tracker->td->status, tracker->td->device);
     220                                list_remove(current);
     221                                list_append(current, &done_trackers);
     222                        }
     223                        current = next;
     224                }
     225
     226                usb_log_debug2("Cleaner(%d) releasing tracker list mutex.\n",
     227                    fibril_get_id());
     228                fibril_mutex_unlock(&instance->tracker_list_mutex);
     229                usb_log_debug2("Cleaner(%d) released tracker list mutex.\n",
     230                    fibril_get_id());
     231
     232                while (!list_empty(&done_trackers)) {
     233                        tracker_t *tracker = list_get_instance(
     234                          done_trackers.next, tracker_t, link);
     235                        list_remove(&tracker->link);
     236                        tracker->next_step(tracker);
     237                }
    187238                async_usleep(UHCI_CLEANER_TIMEOUT);
    188239        }

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

    rd15809b4 r0d36c20  
    4444
    4545#include "transfer_list.h"
    46 #include "batch.h"
     46#include "tracker.h"
    4747
    4848typedef struct uhci_regs {
    … …  
    8181        link_pointer_t *frame_list;
    8282
    83         link_t batch_list;
    84         fibril_mutex_t batch_list_mutex;
     83        link_t tracker_list;
     84        fibril_mutex_t tracker_list_mutex;
    8585
    8686        transfer_list_t transfers_bulk_full;
    … …  
    113113  void *arg );
    114114
    115 int uhci_schedule(uhci_t *instance, batch_t *batch);
     115int uhci_schedule(uhci_t *instance, tracker_t *tracker);
    116116
    117117static inline uhci_t * dev_to_uhci(device_t *dev)

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

    rd15809b4 r0d36c20  
    5555}
    5656
    57 static inline void queue_head_append_qh(queue_head_t *instance, uint32_t pa)
     57static inline void queue_head_add_next(queue_head_t *instance, uint32_t next_queue_pa)
    5858{
    59         if (pa) {
    60                 instance->next_queue = (pa & LINK_POINTER_ADDRESS_MASK)
    61                     | LINK_POINTER_QUEUE_HEAD_FLAG;
     59        if (next_queue_pa) {
     60                instance->next_queue = (next_queue_pa & LINK_POINTER_ADDRESS_MASK)
     61                  | LINK_POINTER_QUEUE_HEAD_FLAG;
    6262        }
    6363}
    6464
    65 static inline void queue_head_element_qh(queue_head_t *instance, uint32_t pa)
    66 {
    67         if (pa) {
    68                 instance->next_queue = (pa & LINK_POINTER_ADDRESS_MASK)
    69                     | LINK_POINTER_QUEUE_HEAD_FLAG;
    70         }
    71 }
    72 
    73 static inline void queue_head_element_td(queue_head_t *instance, uint32_t pa)
    74 {
    75         if (pa) {
    76                 instance->element = (pa & LINK_POINTER_ADDRESS_MASK);
    77         }
    78 }
    79 
    80 static inline queue_head_t * queue_head_get() {
    81         queue_head_t *ret = malloc32(sizeof(queue_head_t));
    82         if (ret)
    83                 queue_head_init(ret);
    84         return ret;
    85 }
     65static inline queue_head_t * queue_head_get()
     66        { return malloc32(sizeof(queue_head_t)); }
    8667
    8768static inline void queue_head_dispose(queue_head_t *head)

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

    rd15809b4 r0d36c20  
    4040void transfer_descriptor_init(transfer_descriptor_t *instance,
    4141    int error_count, size_t size, bool toggle, bool isochronous,
    42     usb_target_t target, int pid, void *buffer, transfer_descriptor_t *next)
     42    usb_target_t target, int pid, void *buffer)
    4343{
    4444        assert(instance);
    4545
    46         instance->next = 0
    47             | LINK_POINTER_VERTICAL_FLAG
    48             | ((next != NULL) ? addr_to_phys(next) : LINK_POINTER_TERMINATE_FLAG);
     46        instance->next = 0 | LINK_POINTER_TERMINATE_FLAG;
    4947
    5048        instance->status = 0
    … …  
    8280#endif
    8381}
     82
     83static inline usb_transaction_outcome_t convert_outcome(uint32_t status)
     84{
     85        /*TODO: refactor into something sane */
     86        /*TODO: add additional usb_errors to usb_outcome_t */
     87
     88        if (status & TD_STATUS_ERROR_STALLED)
     89                return USB_OUTCOME_CRCERROR;
     90
     91        if (status & TD_STATUS_ERROR_BUFFER)
     92                return USB_OUTCOME_CRCERROR;
     93
     94        if (status & TD_STATUS_ERROR_BABBLE)
     95                return USB_OUTCOME_BABBLE;
     96
     97        if (status & TD_STATUS_ERROR_NAK)
     98                return USB_OUTCOME_CRCERROR;
     99
     100  if (status & TD_STATUS_ERROR_CRC)
     101                return USB_OUTCOME_CRCERROR;
     102
     103        if (status & TD_STATUS_ERROR_BIT_STUFF)
     104                return USB_OUTCOME_CRCERROR;
     105
     106//      assert((((status >> TD_STATUS_ERROR_POS) & TD_STATUS_ERROR_MASK)
     107//      | TD_STATUS_ERROR_RESERVED) == TD_STATUS_ERROR_RESERVED);
     108        return USB_OUTCOME_OK;
     109}
    84110/*----------------------------------------------------------------------------*/
    85111int transfer_descriptor_status(transfer_descriptor_t *instance)
    86112{
    87113        assert(instance);
    88 
    89         if ((instance->status & TD_STATUS_ERROR_STALLED) != 0)
    90                 return EIO;
    91 
    92         if ((instance->status & TD_STATUS_ERROR_CRC) != 0)
    93                 return EAGAIN;
    94 
    95         if ((instance->status & TD_STATUS_ERROR_BUFFER) != 0)
    96                 return EAGAIN;
    97 
    98         if ((instance->status & TD_STATUS_ERROR_BABBLE) != 0)
    99                 return EIO;
    100 
    101         if ((instance->status & TD_STATUS_ERROR_NAK) != 0)
    102                 return EAGAIN;
    103 
    104         if ((instance->status & TD_STATUS_ERROR_BIT_STUFF) != 0)
    105                 return EAGAIN;
    106 
     114        if (convert_outcome(instance->status))
     115                return EINVAL; //TODO: use sane error value here
    107116        return EOK;
    108117}

  • uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.h

    rd15809b4 r0d36c20  
    9393void transfer_descriptor_init(transfer_descriptor_t *instance,
    9494    int error_count, size_t size, bool toggle, bool isochronous,
    95     usb_target_t target, int pid, void *buffer, transfer_descriptor_t * next);
     95    usb_target_t target, int pid, void *buffer);
    9696
    9797int transfer_descriptor_status(transfer_descriptor_t *instance);
    98 
    99 static inline size_t transfer_descriptor_actual_size(
    100     transfer_descriptor_t *instance)
    101 {
    102         assert(instance);
    103         return
    104             ((instance->status >> TD_STATUS_ACTLEN_POS) + 1) & TD_STATUS_ACTLEN_MASK;
    105 }
    10698
    10799static inline bool transfer_descriptor_is_active(

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

    rd15809b4 r0d36c20  
    4545#define UHCI_REQUIRED_PAGE_SIZE 4096
    4646
    47 static inline uintptr_t addr_to_phys(void *addr)
     47static inline void * addr_to_phys(void *addr)
    4848{
    4949        uintptr_t result;
    … …  
    5151
    5252        assert(ret == 0);
    53         return (result | ((uintptr_t)addr & 0xfff));
     53        return (void*)(result | ((uintptr_t)addr & 0xfff));
    5454}
    5555

  • uspace/drv/uhci-rhd/port.c

    rd15809b4 r0d36c20  
    3333 */
    3434#include <errno.h>
    35 #include <str_error.h>
    3635
    3736#include <usb/usb.h>    /* usb_address_t */
    3837#include <usb/usbdrv.h> /* usb_drv_*     */
    3938#include <usb/debug.h>
    40 #include <usb/recognise.h>
    4139
    4240#include "port.h"
    … …  
    206204        assert(port->attached_device == 0);
    207205
    208         devman_handle_t hc_handle;
    209         ret = usb_drv_find_hc(port->rh, &hc_handle);
    210         if (ret != EOK) {
    211                 usb_log_error("Failed to get handle of host controller: %s.\n",
    212                     str_error(ret));
    213                 uhci_port_set_enabled(port, false);
    214                 return ENOMEM;
    215         }
    216 
    217         ret = usb_device_register_child_in_devman(usb_address, hc_handle,
    218             port->rh, &port->attached_device);
     206        ret = usb_drv_register_child_in_devman(port->hc_phone, port->rh,
     207          usb_address, &port->attached_device);
     208
    219209        if (ret != EOK) { /* something went wrong */
    220210                usb_log_error("Failed(%d) in usb_drv_register_child.\n", ret);

  • uspace/drv/usbhid/main.c

    rd15809b4 r0d36c20  
    4545#include <str_error.h>
    4646#include <fibril.h>
    47 #include <usb/debug.h>
    48 #include <usb/classes/classes.h>
    4947#include <usb/classes/hid.h>
    5048#include <usb/classes/hidparser.h>
    … …  
    6361#define GUESSED_POLL_ENDPOINT 1
    6462
    65 /** Keyboard polling endpoint description for boot protocol class. */
    66 static usb_endpoint_description_t poll_endpoint_description = {
    67         .transfer_type = USB_TRANSFER_INTERRUPT,
    68         .direction = USB_DIRECTION_IN,
    69         .interface_class = USB_CLASS_HID,
    70         .interface_subclass = USB_HID_SUBCLASS_BOOT,
    71         .interface_protocol = USB_HID_PROTOCOL_KEYBOARD,
    72         .flags = 0
    73 };
    74 
    7563static void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);
    7664static device_ops_t keyboard_ops = {
    … …  
    342330        }
    343331       
    344         /*
    345          * Initialize the interrupt in endpoint.
    346          */
    347         usb_endpoint_mapping_t endpoint_mapping[1] = {
    348                 {
    349                         .pipe = &kbd_dev->poll_pipe,
    350                         .description = &poll_endpoint_description
    351                 }
    352         };
    353         rc = usb_endpoint_pipe_initialize_from_configuration(
    354             endpoint_mapping, 1,
    355             descriptors, config_desc.total_length,
    356             &kbd_dev->wire);
    357         if (rc != EOK) {
    358                 usb_log_error("Failed to initialize poll pipe: %s.\n",
    359                     str_error(rc));
    360                 return rc;
    361         }
    362         if (!endpoint_mapping[0].present) {
    363                 usb_log_warning("Not accepting device, " \
    364                     "not boot-protocol keyboard.\n");
    365                 return EREFUSED;
    366         }
    367 
    368 
    369 
    370 
    371332        kbd_dev->conf = (usb_hid_configuration_t *)calloc(1,
    372333            sizeof(usb_hid_configuration_t));
    … …  
    376337        }
    377338       
    378         /*rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);
     339        rc = usbkbd_parse_descriptors(descriptors, transferred, kbd_dev->conf);
    379340        free(descriptors);
    380341        if (rc != EOK) {
    … …  
    383344        }
    384345
    385         // get and report descriptors*/
     346        // get and report descriptors
    386347        rc = usbkbd_get_report_descriptor(kbd_dev);
    387348        if (rc != EOK) {
    … …  
    400361     *    as the endpoint for polling
    401362         */
    402 
     363       
    403364        return EOK;
    404365}
    … …  
    435396        if (rc != EOK) {
    436397                printf("Failed to initialize default control pipe: %s.\n",
     398                    str_error(rc));
     399                goto error_leave;
     400        }
     401
     402        rc = usb_endpoint_pipe_initialize(&kbd_dev->poll_pipe, &kbd_dev->wire,
     403            GUESSED_POLL_ENDPOINT, USB_TRANSFER_INTERRUPT, USB_DIRECTION_IN);
     404        if (rc != EOK) {
     405                printf("Failed to initialize interrupt in pipe: %s.\n",
    437406                    str_error(rc));
    438407                goto error_leave;
    … …  
    449418        usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
    450419        //usb_request_set_configuration(&kbd_dev->ctrl_pipe, 1);
    451         rc = usbkbd_process_descriptors(kbd_dev);
     420        usbkbd_process_descriptors(kbd_dev);
    452421        usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
    453         if (rc != EOK) {
    454                 goto error_leave;
    455         }
    456422
    457423        return kbd_dev;
    … …  
    611577int main(int argc, char *argv[])
    612578{
    613         usb_log_enable(USB_LOG_LEVEL_INFO, "usbhid");
    614579        return driver_main(&kbd_driver);
    615580}

  • uspace/drv/usbhub/usbhub.c

    rd15809b4 r0d36c20  
    3636#include <bool.h>
    3737#include <errno.h>
    38 #include <str_error.h>
    3938
    4039#include <usb_iface.h>
    4140#include <usb/usbdrv.h>
    4241#include <usb/descriptor.h>
    43 #include <usb/recognise.h>
    4442#include <usb/devreq.h>
    4543#include <usb/classes/hub.h>
    … …  
    319317        }
    320318
    321         devman_handle_t hc_handle;
    322         opResult = usb_drv_find_hc(hub->device, &hc_handle);
    323         if (opResult != EOK) {
    324                 usb_log_error("Failed to get handle of host controller: %s.\n",
    325                     str_error(opResult));
    326                 return;
    327         }
    328 
    329319        devman_handle_t child_handle;
    330         opResult = usb_device_register_child_in_devman(new_device_address,
    331             hc_handle, hub->device, &child_handle);
     320        opResult = usb_drv_register_child_in_devman(hc, hub->device,
     321            new_device_address, &child_handle);
    332322        if (opResult != EOK) {
    333323                dprintf(USB_LOG_LEVEL_ERROR, "could not start driver for new device");

  • uspace/drv/vhc/hub.c

    rd15809b4 r0d36c20  
    4141#include <driver.h>
    4242#include <usb/usbdrv.h>
    43 #include <usb/recognise.h>
    4443
    4544#include "hub.h"
    … …  
    9493
    9594        devman_handle_t hub_handle;
    96         usb_device_register_child_in_devman(hub_address, hc_dev->handle,
    97             hc_dev, &hub_handle);
    98         //usb_drv_register_child_in_devman(hc, hc_dev, hub_address, &hub_handle);
     95        usb_drv_register_child_in_devman(hc, hc_dev, hub_address, &hub_handle);
    9996        usb_drv_bind_address(hc, hub_address, hub_handle);
    10097

  • uspace/lib/usb/Makefile

    rd15809b4 r0d36c20  
    4444        src/localdrv.c \
    4545        src/pipes.c \
    46         src/pipesinit.c \
    4746        src/recognise.c \
    4847        src/remotedrv.c \

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

    rd15809b4 r0d36c20  
    5050        USB_HIDREQ_SET_PROTOCOL = 11
    5151} usb_hid_request_t;
    52 
    53 /** USB/HID subclass constants. */
    54 typedef enum {
    55         USB_HID_SUBCLASS_NONE = 0,
    56         USB_HID_SUBCLASS_BOOT = 1
    57 } usb_hid_subclass_t;
    5852
    5953/** USB/HID interface protocols. */

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

    rd15809b4 r0d36c20  
    3838#include <sys/types.h>
    3939#include <usb/usb.h>
    40 #include <usb/descriptor.h>
    4140#include <ipc/devman.h>
    4241#include <driver.h>
    … …  
    7473        usb_direction_t direction;
    7574
    76         /** Maximum packet size for the endpoint. */
    77         size_t max_packet_size;
    78 
    7975        /** Phone to the host controller.
    8076         * Negative when no session is active.
    … …  
    8379} usb_endpoint_pipe_t;
    8480
    85 
    86 /** Description of endpoint characteristics. */
    87 typedef struct {
    88         /** Transfer type (e.g. control or interrupt). */
    89         usb_transfer_type_t transfer_type;
    90         /** Transfer direction (to or from a device). */
    91         usb_direction_t direction;
    92         /** Interface class this endpoint belongs to (-1 for any). */
    93         int interface_class;
    94         /** Interface subclass this endpoint belongs to (-1 for any). */
    95         int interface_subclass;
    96         /** Interface protocol this endpoint belongs to (-1 for any). */
    97         int interface_protocol;
    98         /** Extra endpoint flags. */
    99         unsigned int flags;
    100 } usb_endpoint_description_t;
    101 
    102 /** Mapping of endpoint pipes and endpoint descriptions. */
    103 typedef struct {
    104         /** Endpoint pipe. */
    105         usb_endpoint_pipe_t *pipe;
    106         /** Endpoint description. */
    107         const usb_endpoint_description_t *description;
    108         /** Found descriptor fitting the description. */
    109         usb_standard_endpoint_descriptor_t *descriptor;
    110         /** Interface the endpoint belongs to. */
    111         usb_standard_interface_descriptor_t *interface;
    112         /** Whether the endpoint was actually found. */
    113         bool present;
    114 } usb_endpoint_mapping_t;
    11581
    11682int usb_device_connection_initialize_from_device(usb_device_connection_t *,
    … …  
    12187int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *,
    12288    usb_device_connection_t *,
    123     usb_endpoint_t, usb_transfer_type_t, size_t, usb_direction_t);
     89    usb_endpoint_t, usb_transfer_type_t, usb_direction_t);
    12490int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *,
    12591    usb_device_connection_t *);
    126 int usb_endpoint_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
    127     size_t, uint8_t *, size_t, usb_device_connection_t *);
    12892
    12993

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

    rd15809b4 r0d36c20  
    106106    const void *, size_t);
    107107
     108int usb_drv_create_device_match_ids(int, match_id_list_t *, usb_address_t);
     109int usb_drv_register_child_in_devman(int, device_t *, usb_address_t,
     110    devman_handle_t *);
     111
    108112
    109113#endif

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

    rd15809b4 r0d36c20  
    123123 * @param endpoint_no Endpoint number (in USB 1.1 in range 0 to 15).
    124124 * @param transfer_type Transfer type (e.g. interrupt or bulk).
    125  * @param max_packet_size Maximum packet size in bytes.
    126125 * @param direction Endpoint direction (in/out).
    127126 * @return Error code.
    … …  
    129128int usb_endpoint_pipe_initialize(usb_endpoint_pipe_t *pipe,
    130129    usb_device_connection_t *connection, usb_endpoint_t endpoint_no,
    131     usb_transfer_type_t transfer_type, size_t max_packet_size,
    132     usb_direction_t direction)
     130    usb_transfer_type_t transfer_type, usb_direction_t direction)
    133131{
    134132        assert(pipe);
    … …  
    139137        pipe->endpoint_no = endpoint_no;
    140138        pipe->transfer_type = transfer_type;
    141         pipe->max_packet_size = max_packet_size;
    142139        pipe->direction = direction;
    143140
    … …  
    159156
    160157        int rc = usb_endpoint_pipe_initialize(pipe, connection,
    161             0, USB_TRANSFER_CONTROL, 8, USB_DIRECTION_BOTH);
     158            0, USB_TRANSFER_CONTROL, USB_DIRECTION_BOTH);
    162159
    163160        return rc;

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

    rd15809b4 r0d36c20  
    3636#include <usb_iface.h>
    3737#include <usb/usbdrv.h>
    38 #include <usb/pipes.h>
    39 #include <usb/recognise.h>
    40 #include <usb/request.h>
    4138#include <usb/classes/classes.h>
    4239#include <stdio.h>
    4340#include <errno.h>
    44 
    45 static size_t device_name_index = 0;
    46 static FIBRIL_MUTEX_INITIALIZE(device_name_index_mutex);
    4741
    4842/** Callback for getting host controller handle.
    … …  
    7670};
    7771
    78 device_ops_t child_ops = {
     72static device_ops_t child_ops = {
    7973        .interfaces[USB_DEV_IFACE] = &usb_iface
    8074};
    … …  
    161155                /* First, with release number. */
    162156                rc = usb_add_match_id(matches, 100,
    163                     "usb&vendor=0x%04x&product=0x%04x&release=" BCD_FMT,
     157                    "usb&vendor=%d&product=%d&release=" BCD_FMT,
    164158                    (int) device_descriptor->vendor_id,
    165159                    (int) device_descriptor->product_id,
    … …  
    170164               
    171165                /* Next, without release number. */
    172                 rc = usb_add_match_id(matches, 90,
    173                     "usb&vendor=0x%04x&product=0x%04x",
     166                rc = usb_add_match_id(matches, 90, "usb&vendor=%d&product=%d",
    174167                    (int) device_descriptor->vendor_id,
    175168                    (int) device_descriptor->product_id);
    … …  
    248241/** Add match ids based on configuration descriptor.
    249242 *
    250  * @param pipe Control pipe to the device.
     243 * @param hc Open phone to host controller.
    251244 * @param matches Match ids list to add matches to.
     245 * @param address USB address of the attached device.
    252246 * @param config_count Number of configurations the device has.
    253247 * @return Error code.
    254248 */
    255 static int usb_add_config_descriptor_match_ids(usb_endpoint_pipe_t *pipe,
    256     match_id_list_t *matches, int config_count)
     249static int usb_add_config_descriptor_match_ids(int hc,
     250    match_id_list_t *matches, usb_address_t address,
     251    int config_count)
    257252{
    258253        int final_rc = EOK;
    … …  
    262257                int rc;
    263258                usb_standard_configuration_descriptor_t config_descriptor;
    264                 rc = usb_request_get_bare_configuration_descriptor(pipe,
    265                     config_index, &config_descriptor);
     259                rc = usb_drv_req_get_bare_configuration_descriptor(hc,
     260                    address,  config_index, &config_descriptor);
    266261                if (rc != EOK) {
    267262                        final_rc = rc;
    … …  
    272267                void *full_config_descriptor
    273268                    = malloc(config_descriptor.total_length);
    274                 rc = usb_request_get_full_configuration_descriptor(pipe,
    275                     config_index,
     269                rc = usb_drv_req_get_full_configuration_descriptor(hc,
     270                    address, config_index,
    276271                    full_config_descriptor, config_descriptor.total_length,
    277272                    &full_config_descriptor_size);
    … …  
    304299 * function exits with error.
    305300 *
    306  * @param ctrl_pipe Control pipe to given device (session must be already
    307  *      started).
     301 * @param hc Open phone to host controller.
    308302 * @param matches Initialized list of match ids.
    309  * @return Error code.
    310  */
    311 int usb_device_create_match_ids(usb_endpoint_pipe_t *ctrl_pipe,
    312     match_id_list_t *matches)
     303 * @param address USB address of the attached device.
     304 * @return Error code.
     305 */
     306int usb_drv_create_device_match_ids(int hc, match_id_list_t *matches,
     307    usb_address_t address)
    313308{
    314309        int rc;
     310       
    315311        /*
    316312         * Retrieve device descriptor and add matches from it.
    … …  
    318314        usb_standard_device_descriptor_t device_descriptor;
    319315
    320         rc = usb_request_get_device_descriptor(ctrl_pipe, &device_descriptor);
     316        rc = usb_drv_req_get_device_descriptor(hc, address,
     317            &device_descriptor);
    321318        if (rc != EOK) {
    322319                return rc;
    323320        }
    324 
     321       
    325322        rc = usb_drv_create_match_ids_from_device_descriptor(matches,
    326323            &device_descriptor);
    … …  
    328325                return rc;
    329326        }
    330 
     327       
    331328        /*
    332329         * Go through all configurations and add matches
    333330         * based on interface class.
    334331         */
    335         rc = usb_add_config_descriptor_match_ids(ctrl_pipe, matches,
    336             device_descriptor.configuration_count);
     332        rc = usb_add_config_descriptor_match_ids(hc, matches,
     333            address, device_descriptor.configuration_count);
    337334        if (rc != EOK) {
    338335                return rc;
    … …  
    350347}
    351348
     349
    352350/** Probe for device kind and register it in devman.
    353351 *
     352 * @param[in] hc Open phone to the host controller.
     353 * @param[in] parent Parent device.
    354354 * @param[in] address Address of the (unknown) attached device.
    355  * @param[in] hc_handle Handle of the host controller.
    356  * @param[in] parent Parent device.
    357355 * @param[out] child_handle Handle of the child device.
    358356 * @return Error code.
    359357 */
    360 int usb_device_register_child_in_devman(usb_address_t address,
    361     devman_handle_t hc_handle,
    362     device_t *parent, devman_handle_t *child_handle)
    363 {
     358int usb_drv_register_child_in_devman(int hc, device_t *parent,
     359    usb_address_t address, devman_handle_t *child_handle)
     360{
     361        static size_t device_name_index = 0;
     362        static FIBRIL_MUTEX_INITIALIZE(device_name_index_mutex);
     363
    364364        size_t this_device_name_index;
    365365
    … …  
    369369        fibril_mutex_unlock(&device_name_index_mutex);
    370370
     371
    371372        device_t *child = NULL;
    372373        char *child_name = NULL;
    373374        int rc;
    374         usb_device_connection_t dev_connection;
    375         usb_endpoint_pipe_t ctrl_pipe;
    376 
    377         rc = usb_device_connection_initialize(&dev_connection, hc_handle, address);
    378         if (rc != EOK) {
    379                 goto failure;
    380         }
    381 
    382         rc = usb_endpoint_pipe_initialize_default_control(&ctrl_pipe,
    383             &dev_connection);
    384         if (rc != EOK) {
    385                 goto failure;
    386         }
    387375
    388376        child = create_device();
    … …  
    403391        child->name = child_name;
    404392        child->ops = &child_ops;
    405 
    406         rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
    407         if (rc != EOK) {
    408                 goto failure;
    409         }
    410 
    411         rc = usb_device_create_match_ids(&ctrl_pipe, &child->match_ids);
    412         if (rc != EOK) {
    413                 goto failure;
    414         }
    415 
    416         rc = usb_endpoint_pipe_end_session(&ctrl_pipe);
     393       
     394        rc = usb_drv_create_device_match_ids(hc, &child->match_ids, address);
    417395        if (rc != EOK) {
    418396                goto failure;
    … …  
    427405                *child_handle = child->handle;
    428406        }
    429 
     407       
    430408        return EOK;
    431409
    … …  
    441419
    442420        return rc;
     421
    443422}
    444423
Note: See TracChangeset for help on using the changeset viewer.