Changeset 54d9058 in mainline


Ignore:
Timestamp:
2011-02-13T11:16:58Z (13 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
b53ca1e
Parents:
dc04868 (diff), 45c01a1 (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 development/ changes

Location:
uspace/drv/uhci-hcd
Files:
1 added
1 deleted
10 edited
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci-hcd/Makefile

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

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

    rdc04868 r54d9058  
    3232 * @brief UHCI driver
    3333 */
    34 #ifndef DRV_UHCI_TRACKER_H
    35 #define DRV_UHCI_TRACKER_H
     34#ifndef DRV_UHCI_BATCH_H
     35#define DRV_UHCI_BATCH_H
    3636
    3737#include <adt/list.h>
    … …  
    4141
    4242#include "uhci_struct/transfer_descriptor.h"
     43#include "uhci_struct/queue_head.h"
    4344
    4445typedef enum {
    … …  
    4748} dev_speed_t;
    4849
    49 struct transfer_list;
    50 
    51 typedef struct tracker
     50typedef struct batch
    5251{
    5352        link_t link;
     53        dev_speed_t speed;
    5454        usb_target_t target;
    5555        usb_transfer_type_t transfer_type;
    … …  
    5959        };
    6060        void *arg;
     61        char *transport_buffer;
     62        char *setup_buffer;
     63        size_t setup_size;
    6164        char *buffer;
    62         char *packet;
    6365        size_t buffer_size;
    6466        size_t max_packet_size;
    65         size_t packet_size;
    66         size_t buffer_offset;
    67         dev_speed_t speed;
     67        size_t packets;
     68        size_t transfered_size;
     69        int error;
    6870        device_t *dev;
    69         transfer_descriptor_t *td;
    70         void (*next_step)(struct tracker*);
    71         unsigned toggle:1;
     71        queue_head_t *qh;
     72        transfer_descriptor_t *tds;
     73        void (*next_step)(struct batch*);
     74} batch_t;
    7275
    73         struct transfer_list *scheduled_list;
    74 } tracker_t;
    75 
    76 
    77 tracker_t * tracker_get(device_t *dev, usb_target_t target,
     76batch_t * batch_get(device_t *dev, usb_target_t target,
    7877    usb_transfer_type_t transfer_type, size_t max_packet_size,
    7978    dev_speed_t speed, char *buffer, size_t size,
     79                char *setup_buffer, size_t setup_size,
    8080    usbhc_iface_transfer_in_callback_t func_in,
    8181    usbhc_iface_transfer_out_callback_t func_out, void *arg);
    8282
    83 void tracker_control_write(
    84     tracker_t *instance, char* setup_buffer, size_t setup_size);
     83bool batch_is_complete(batch_t *instance);
    8584
    86 void tracker_control_read(
    87     tracker_t *instance, char* setup_buffer, size_t setup_size);
     85void batch_control_write(batch_t *instance);
    8886
    89 void tracker_interrupt_in(tracker_t *instance);
     87void batch_control_read(batch_t *instance);
    9088
    91 void tracker_interrupt_out(tracker_t *instance);
     89void batch_interrupt_in(batch_t *instance);
     90
     91void batch_interrupt_out(batch_t *instance);
    9292
    9393/* DEPRECATED FUNCTIONS NEEDED BY THE OLD API */
    94 void tracker_control_setup_old(tracker_t *instance);
     94void batch_control_setup_old(batch_t *instance);
    9595
    96 void tracker_control_write_data_old(tracker_t *instance);
     96void batch_control_write_data_old(batch_t *instance);
    9797
    98 void tracker_control_read_data_old(tracker_t *instance);
     98void batch_control_read_data_old(batch_t *instance);
    9999
    100 void tracker_control_write_status_old(tracker_t *instance);
     100void batch_control_write_status_old(batch_t *instance);
    101101
    102 void tracker_control_read_status_old(tracker_t *instance);
     102void batch_control_read_status_old(batch_t *instance);
    103103#endif
    104104/**

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

    rdc04868 r54d9058  
    109109        dev_speed_t speed = FULL_SPEED;
    110110
    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);
     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);
    116116        return EOK;
    117117}
    … …  
    124124        dev_speed_t speed = FULL_SPEED;
    125125
    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);
     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);
    131131        return EOK;
    132132}
    … …  
    139139        dev_speed_t speed = FULL_SPEED;
    140140
    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);
     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);
    146147        return EOK;
    147148}
    … …  
    154155        dev_speed_t speed = FULL_SPEED;
    155156
    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);
     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);
    161163        return EOK;
    162164}
    … …  
    166168    usbhc_iface_transfer_out_callback_t callback, void *arg)
    167169{
    168         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    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);
     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);
    174179        return EOK;
    175180}
    … …  
    179184    usbhc_iface_transfer_out_callback_t callback, void *arg)
    180185{
    181         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    182         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    183             size, FULL_SPEED, data, size, NULL, callback, arg);
    184         if (!tracker)
    185                 return ENOMEM;
    186         tracker_control_write_data_old(tracker);
     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);
    187195        return EOK;
    188196}
    … …  
    191199    usbhc_iface_transfer_in_callback_t callback, void *arg)
    192200{
    193         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    194         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    195             0, FULL_SPEED, NULL, 0, callback, NULL, arg);
    196         if (!tracker)
    197                 return ENOMEM;
    198         tracker_control_write_status_old(tracker);
     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);
    199210        return EOK;
    200211}
    … …  
    204215    usbhc_iface_transfer_out_callback_t callback, void *arg)
    205216{
    206         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    207         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    208             8, FULL_SPEED, data, size, NULL, callback, arg);
    209         if (!tracker)
    210                 return ENOMEM;
    211         tracker_control_setup_old(tracker);
     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);
    212226        return EOK;
    213227}
    … …  
    217231    usbhc_iface_transfer_in_callback_t callback, void *arg)
    218232{
    219         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    220         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    221             size, FULL_SPEED, data, size, callback, NULL, arg);
    222         if (!tracker)
    223                 return ENOMEM;
    224         tracker_control_read_data_old(tracker);
     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);
    225242        return EOK;
    226243}
    … …  
    229246    usbhc_iface_transfer_out_callback_t callback, void *arg)
    230247{
    231         usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    232         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
    233             0, FULL_SPEED, NULL, 0, NULL, callback, arg);
    234         if (!tracker)
    235                 return ENOMEM;
    236         tracker_control_read_status_old(tracker);
     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);
    237257        return EOK;
    238258}

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

    rdc04868 r54d9058  
    5151
    5252        queue_head_init(instance->queue_head);
     53        list_initialize(&instance->batch_list);
     54        fibril_mutex_initialize(&instance->guard);
    5355        return EOK;
    5456}
    … …  
    5860        assert(instance);
    5961        assert(next);
    60         instance->next = next;
    6162        if (!instance->queue_head)
    6263                return;
    63         queue_head_add_next(instance->queue_head, next->queue_head_pa);
     64        queue_head_append_qh(instance->queue_head, next->queue_head_pa);
     65        instance->queue_head->element = instance->queue_head->next_queue;
    6466}
    6567/*----------------------------------------------------------------------------*/
    66 void transfer_list_add_tracker(transfer_list_t *instance, tracker_t *tracker)
     68void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch)
    6769{
    6870        assert(instance);
    69         assert(tracker);
     71        assert(batch);
    7072
    71         uint32_t pa = (uintptr_t)addr_to_phys(tracker->td);
     73        uint32_t pa = (uintptr_t)addr_to_phys(batch->qh);
    7274        assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
     75        pa |= LINK_POINTER_QUEUE_HEAD_FLAG;
    7376
     77        batch->qh->next_queue = instance->queue_head->next_queue;
    7478
    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);
     79        fibril_mutex_lock(&instance->guard);
     80
     81        if (instance->queue_head->element == instance->queue_head->next_queue) {
    7882                /* there is nothing scheduled */
    79                 instance->last_tracker = tracker;
     83                list_append(&batch->link, &instance->batch_list);
    8084                instance->queue_head->element = pa;
    81                 usb_log_debug2("Added td(%X:%X) to queue %s first.\n",
    82                         tracker->td->status, tracker->td->device, instance->name);
     85                usb_log_debug2("Added batch(%p) to queue %s first.\n",
     86                        batch, instance->name);
     87                fibril_mutex_unlock(&instance->guard);
    8388                return;
    8489        }
    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;
    91 
    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);
    100         }
     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);
    101101}
    102102/*----------------------------------------------------------------------------*/
    103 void transfer_list_remove_tracker(transfer_list_t *instance, tracker_t *tracker)
     103static void transfer_list_remove_batch(
     104    transfer_list_t *instance, batch_t *batch)
    104105{
    105106        assert(instance);
    106         assert(tracker);
     107        assert(batch);
    107108        assert(instance->queue_head);
    108         assert(tracker->td);
     109        assert(batch->qh);
    109110
    110         uint32_t pa = (uintptr_t)addr_to_phys(tracker->td);
    111         if ((instance->queue_head->element & LINK_POINTER_ADDRESS_MASK) == pa) {
    112                 instance->queue_head->element = tracker->td->next;
     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;
    113121        }
     122        list_remove(&batch->link);
     123}
     124/*----------------------------------------------------------------------------*/
     125void 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);
    114141}
    115142/**

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

    rdc04868 r54d9058  
    3535#define DRV_UHCI_TRANSFER_LIST_H
    3636
     37#include <fibril_synch.h>
     38
    3739#include "uhci_struct/queue_head.h"
    3840
    39 #include "tracker.h"
     41#include "batch.h"
    4042
    4143typedef struct transfer_list
    4244{
    43         tracker_t *last_tracker;
    44 
     45        fibril_mutex_t guard;
    4546        queue_head_t *queue_head;
    4647        uint32_t queue_head_pa;
    4748        struct transfer_list *next;
    4849        const char *name;
     50        link_t batch_list;
    4951} transfer_list_t;
    5052
    … …  
    5355void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next);
    5456
    55 
    5657static inline void transfer_list_fini(transfer_list_t *instance)
    5758{
    … …  
    5960        queue_head_dispose(instance->queue_head);
    6061}
     62void transfer_list_check(transfer_list_t *instance);
    6163
    62 void transfer_list_add_tracker(transfer_list_t *instance, tracker_t *tracker);
    63 
    64 void transfer_list_remove_tracker(transfer_list_t *instance, tracker_t *track);
    65 
     64void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);
    6665#endif
    6766/**

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

    rdc04868 r54d9058  
    8989        pio_write_32(&instance->registers->flbaseadd, (uint32_t)pa);
    9090
    91         list_initialize(&instance->tracker_list);
    92         fibril_mutex_initialize(&instance->tracker_list_mutex);
     91        list_initialize(&instance->batch_list);
     92        fibril_mutex_initialize(&instance->batch_list_mutex);
    9393
    9494        instance->cleaner = fibril_create(uhci_clean_finished, instance);
    … …  
    152152}
    153153/*----------------------------------------------------------------------------*/
    154 int uhci_schedule(uhci_t *instance, tracker_t *tracker)
    155 {
    156         assert(instance);
    157         assert(tracker);
    158         const int low_speed = (tracker->speed == LOW_SPEED);
     154int uhci_schedule(uhci_t *instance, batch_t *batch)
     155{
     156        assert(instance);
     157        assert(batch);
     158        const int low_speed = (batch->speed == LOW_SPEED);
    159159        if (!allowed_usb_packet(
    160             low_speed, tracker->transfer_type, tracker->packet_size)) {
     160            low_speed, batch->transfer_type, batch->max_packet_size)) {
    161161                usb_log_warning("Invalid USB packet specified %s SPEED %d %zu.\n",
    162                           low_speed ? "LOW" : "FULL" , tracker->transfer_type,
    163                     tracker->packet_size);
     162                          low_speed ? "LOW" : "FULL" , batch->transfer_type,
     163                    batch->max_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 
    174168        transfer_list_t *list =
    175             instance->transfers[low_speed][tracker->transfer_type];
     169            instance->transfers[low_speed][batch->transfer_type];
    176170        assert(list);
    177         transfer_list_add_tracker(list, tracker);
    178         list_append(&tracker->link, &instance->tracker_list);
    179 
    180         tracker->scheduled_list = list;
    181 
    182         usb_log_debug2("Scheduler(%d) releasing tracker list mutex.\n",
    183             fibril_get_id());
    184         fibril_mutex_unlock(&instance->tracker_list_mutex);
    185         usb_log_debug2("Scheduler(%d) released tracker list mutex.\n",
    186             fibril_get_id());
     171        transfer_list_add_batch(list, batch);
    187172
    188173        return EOK;
    … …  
    196181
    197182        while(1) {
    198                 LIST_INITIALIZE(done_trackers);
    199                 /* tracker iteration */
    200 
    201                 usb_log_debug2("Cleaner(%d) acquiring tracker list mutex.\n",
    202                     fibril_get_id());
    203                 fibril_mutex_lock(&instance->tracker_list_mutex);
    204                 usb_log_debug2("Cleaner(%d) acquired tracker list mutex.\n",
    205                     fibril_get_id());
    206 
    207                 link_t *current = instance->tracker_list.next;
    208                 while (current != &instance->tracker_list)
    209                 {
    210 
    211                         link_t *next = current->next;
    212                         tracker_t *tracker = list_get_instance(current, tracker_t, link);
    213 
    214                         assert(current == &tracker->link);
    215                         assert(tracker);
    216                         assert(tracker->next_step);
    217                         assert(tracker->td);
    218 
    219                         if (!transfer_descriptor_is_active(tracker->td)) {
    220                                 usb_log_info("Found inactive tracker with status: %x:%x.\n",
    221                                     tracker->td->status, tracker->td->device);
    222                                 list_remove(current);
    223                                 list_append(current, &done_trackers);
    224                         }
    225                         current = next;
    226                 }
    227 
    228                 usb_log_debug2("Cleaner(%d) releasing tracker list mutex.\n",
    229                     fibril_get_id());
    230                 fibril_mutex_unlock(&instance->tracker_list_mutex);
    231                 usb_log_debug2("Cleaner(%d) released tracker list mutex.\n",
    232                     fibril_get_id());
    233 
    234                 while (!list_empty(&done_trackers)) {
    235                         tracker_t *tracker = list_get_instance(
    236                           done_trackers.next, tracker_t, link);
    237                         list_remove(&tracker->link);
    238                         tracker->next_step(tracker);
    239                 }
     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);
    240187                async_usleep(UHCI_CLEANER_TIMEOUT);
    241188        }

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

    rdc04868 r54d9058  
    4444
    4545#include "transfer_list.h"
    46 #include "tracker.h"
     46#include "batch.h"
    4747
    4848typedef struct uhci_regs {
    … …  
    7272
    7373#define UHCI_FRAME_LIST_COUNT 1024
    74 #define UHCI_CLEANER_TIMEOUT 1000
     74#define UHCI_CLEANER_TIMEOUT 10000
    7575#define UHCI_DEBUGER_TIMEOUT 5000000
    7676
    … …  
    8181        link_pointer_t *frame_list;
    8282
    83         link_t tracker_list;
    84         fibril_mutex_t tracker_list_mutex;
     83        link_t batch_list;
     84        fibril_mutex_t batch_list_mutex;
    8585
    8686        transfer_list_t transfers_bulk_full;
    … …  
    113113  void *arg );
    114114
    115 int uhci_schedule(uhci_t *instance, tracker_t *tracker);
     115int uhci_schedule(uhci_t *instance, batch_t *batch);
    116116
    117117static inline uhci_t * dev_to_uhci(device_t *dev)

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

    rdc04868 r54d9058  
    5555}
    5656
    57 static inline void queue_head_add_next(queue_head_t *instance, uint32_t next_queue_pa)
     57static inline void queue_head_append_qh(queue_head_t *instance, uint32_t pa)
    5858{
    59         if (next_queue_pa) {
    60                 instance->next_queue = (next_queue_pa & LINK_POINTER_ADDRESS_MASK)
    61                   | LINK_POINTER_QUEUE_HEAD_FLAG;
     59        if (pa) {
     60                instance->next_queue = (pa & LINK_POINTER_ADDRESS_MASK)
     61                    | LINK_POINTER_QUEUE_HEAD_FLAG;
    6262        }
    6363}
    6464
    65 static inline queue_head_t * queue_head_get()
    66         { return malloc32(sizeof(queue_head_t)); }
     65static 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
     73static 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
     80static 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}
    6786
    6887static inline void queue_head_dispose(queue_head_t *head)

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

    rdc04868 r54d9058  
    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)
     42    usb_target_t target, int pid, void *buffer, transfer_descriptor_t *next)
    4343{
    4444        assert(instance);
    4545
    46         instance->next = 0 | LINK_POINTER_TERMINATE_FLAG;
     46        instance->next = 0
     47            | LINK_POINTER_VERTICAL_FLAG
     48            | ((next != NULL) ? addr_to_phys(next) : LINK_POINTER_TERMINATE_FLAG);
    4749
    4850        instance->status = 0

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

    rdc04868 r54d9058  
    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);
     95    usb_target_t target, int pid, void *buffer, transfer_descriptor_t * next);
    9696
    9797int transfer_descriptor_status(transfer_descriptor_t *instance);
     98
     99static 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}
    98106
    99107static inline bool transfer_descriptor_is_active(

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

    rdc04868 r54d9058  
    4545#define UHCI_REQUIRED_PAGE_SIZE 4096
    4646
    47 static inline void * addr_to_phys(void *addr)
     47static inline uintptr_t addr_to_phys(void *addr)
    4848{
    4949        uintptr_t result;
    … …  
    5151
    5252        assert(ret == 0);
    53         return (void*)(result | ((uintptr_t)addr & 0xfff));
     53        return (result | ((uintptr_t)addr & 0xfff));
    5454}
    5555
Note: See TracChangeset for help on using the changeset viewer.