Changeset 83c439c in mainline


Ignore:
Timestamp:
2011-02-12T02:12:52Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2806cd2
Parents:
7dd3318
Message:

Rename tracker⇒batch

Location:
uspace/drv/uhci-hcd
Files:
6 edited
2 moved

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci-hcd/Makefile

    r7dd3318 r83c439c  
    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.c

    r7dd3318 r83c439c  
    3636#include <usb/debug.h>
    3737
    38 #include "tracker.h"
     38#include "batch.h"
    3939#include "transfer_list.h"
    4040#include "uhci.h"
    … …  
    4343#define DEFAULT_ERROR_COUNT 3
    4444
    45 static int tracker_schedule(tracker_t *instance);
    46 
    47 static void tracker_call_in(tracker_t *instance);
    48 static void tracker_call_out(tracker_t *instance);
    49 static void tracker_call_in_and_dispose(tracker_t *instance);
    50 static void tracker_call_out_and_dispose(tracker_t *instance);
    51 
    52 
    53 tracker_t * tracker_get(device_t *dev, usb_target_t target,
     45static int batch_schedule(batch_t *instance);
     46
     47static void batch_call_in(batch_t *instance);
     48static void batch_call_out(batch_t *instance);
     49static void batch_call_in_and_dispose(batch_t *instance);
     50static void batch_call_out_and_dispose(batch_t *instance);
     51
     52
     53batch_t * batch_get(device_t *dev, usb_target_t target,
    5454    usb_transfer_type_t transfer_type, size_t max_packet_size,
    5555    dev_speed_t speed, char *buffer, size_t size,
    … …  
    6161        assert(func_in != NULL || func_out != NULL);
    6262
    63         tracker_t *instance = malloc(sizeof(tracker_t));
     63        batch_t *instance = malloc(sizeof(batch_t));
    6464        if (instance == NULL) {
    65                 usb_log_error("Failed to allocate tracker instance.\n");
     65                usb_log_error("Failed to allocate batch instance.\n");
    6666                return NULL;
    6767        }
    … …  
    136136}
    137137/*----------------------------------------------------------------------------*/
    138 bool tracker_is_complete(tracker_t *instance)
     138bool batch_is_complete(batch_t *instance)
    139139{
    140140        assert(instance);
    … …  
    157157}
    158158/*----------------------------------------------------------------------------*/
    159 void tracker_control_write(tracker_t *instance)
     159void batch_control_write(batch_t *instance)
    160160{
    161161        assert(instance);
    … …  
    187187            0, 1, false, instance->target, USB_PID_IN, NULL, NULL);
    188188
    189         instance->next_step = tracker_call_out_and_dispose;
    190         tracker_schedule(instance);
    191 }
    192 /*----------------------------------------------------------------------------*/
    193 void tracker_control_read(tracker_t *instance)
     189        instance->next_step = batch_call_out_and_dispose;
     190        batch_schedule(instance);
     191}
     192/*----------------------------------------------------------------------------*/
     193void batch_control_read(batch_t *instance)
    194194{
    195195        assert(instance);
    … …  
    218218            0, 1, false, instance->target, USB_PID_OUT, NULL, NULL);
    219219
    220         instance->next_step = tracker_call_in_and_dispose;
    221         tracker_schedule(instance);
    222 }
    223 /*----------------------------------------------------------------------------*/
    224 void tracker_interrupt_in(tracker_t *instance)
     220        instance->next_step = batch_call_in_and_dispose;
     221        batch_schedule(instance);
     222}
     223/*----------------------------------------------------------------------------*/
     224void batch_interrupt_in(batch_t *instance)
    225225{
    226226        assert(instance);
    … …  
    240240        }
    241241
    242         instance->next_step = tracker_call_in_and_dispose;
    243         tracker_schedule(instance);
    244 }
    245 /*----------------------------------------------------------------------------*/
    246 void tracker_interrupt_out(tracker_t *instance)
     242        instance->next_step = batch_call_in_and_dispose;
     243        batch_schedule(instance);
     244}
     245/*----------------------------------------------------------------------------*/
     246void batch_interrupt_out(batch_t *instance)
    247247{
    248248        assert(instance);
    … …  
    264264        }
    265265
    266         instance->next_step = tracker_call_out_and_dispose;
    267         tracker_schedule(instance);
    268 }
    269 /*----------------------------------------------------------------------------*/
    270 void tracker_call_in(tracker_t *instance)
     266        instance->next_step = batch_call_out_and_dispose;
     267        batch_schedule(instance);
     268}
     269/*----------------------------------------------------------------------------*/
     270void batch_call_in(batch_t *instance)
    271271{
    272272        assert(instance);
    … …  
    284284}
    285285/*----------------------------------------------------------------------------*/
    286 void tracker_call_out(tracker_t *instance)
     286void batch_call_out(batch_t *instance)
    287287{
    288288        assert(instance);
    … …  
    295295}
    296296/*----------------------------------------------------------------------------*/
    297 void tracker_call_in_and_dispose(tracker_t *instance)
    298 {
    299         assert(instance);
    300         tracker_call_in(instance);
    301         usb_log_debug("Disposing tracker: %p.\n", instance);
     297void batch_call_in_and_dispose(batch_t *instance)
     298{
     299        assert(instance);
     300        batch_call_in(instance);
     301        usb_log_debug("Disposing batch: %p.\n", instance);
    302302        free32(instance->tds);
    303303        free32(instance->qh);
    … …  
    307307}
    308308/*----------------------------------------------------------------------------*/
    309 void tracker_call_out_and_dispose(tracker_t *instance)
    310 {
    311         assert(instance);
    312         tracker_call_out(instance);
    313         usb_log_debug("Disposing tracker: %p.\n", instance);
     309void batch_call_out_and_dispose(batch_t *instance)
     310{
     311        assert(instance);
     312        batch_call_out(instance);
     313        usb_log_debug("Disposing batch: %p.\n", instance);
    314314        free32(instance->tds);
    315315        free32(instance->qh);
    … …  
    319319}
    320320/*----------------------------------------------------------------------------*/
    321 int tracker_schedule(tracker_t *instance)
     321int batch_schedule(batch_t *instance)
    322322{
    323323        assert(instance);
    … …  
    328328/*----------------------------------------------------------------------------*/
    329329/* DEPRECATED FUNCTIONS NEEDED BY THE OLD API */
    330 void tracker_control_setup_old(tracker_t *instance)
     330void batch_control_setup_old(batch_t *instance)
    331331{
    332332        assert(instance);
    … …  
    338338            USB_PID_SETUP, instance->setup_buffer, NULL);
    339339
    340         instance->next_step = tracker_call_out_and_dispose;
    341         tracker_schedule(instance);
    342 }
    343 /*----------------------------------------------------------------------------*/
    344 void tracker_control_write_data_old(tracker_t *instance)
     340        instance->next_step = batch_call_out_and_dispose;
     341        batch_schedule(instance);
     342}
     343/*----------------------------------------------------------------------------*/
     344void batch_control_write_data_old(batch_t *instance)
    345345{
    346346        assert(instance);
    347347        instance->packets -= 2;
    348         tracker_interrupt_out(instance);
    349 }
    350 /*----------------------------------------------------------------------------*/
    351 void tracker_control_read_data_old(tracker_t *instance)
     348        batch_interrupt_out(instance);
     349}
     350/*----------------------------------------------------------------------------*/
     351void batch_control_read_data_old(batch_t *instance)
    352352{
    353353        assert(instance);
    354354        instance->packets -= 2;
    355         tracker_interrupt_in(instance);
    356 }
    357 /*----------------------------------------------------------------------------*/
    358 void tracker_control_write_status_old(tracker_t *instance)
     355        batch_interrupt_in(instance);
     356}
     357/*----------------------------------------------------------------------------*/
     358void batch_control_write_status_old(batch_t *instance)
    359359{
    360360        assert(instance);
    … …  
    362362        transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
    363363            0, 1, false, instance->target, USB_PID_IN, NULL, NULL);
    364         instance->next_step = tracker_call_in_and_dispose;
    365         tracker_schedule(instance);
    366 }
    367 /*----------------------------------------------------------------------------*/
    368 void tracker_control_read_status_old(tracker_t *instance)
     364        instance->next_step = batch_call_in_and_dispose;
     365        batch_schedule(instance);
     366}
     367/*----------------------------------------------------------------------------*/
     368void batch_control_read_status_old(batch_t *instance)
    369369{
    370370        assert(instance);
    … …  
    372372        transfer_descriptor_init(instance->tds, DEFAULT_ERROR_COUNT,
    373373            0, 1, false, instance->target, USB_PID_OUT, NULL, NULL);
    374         instance->next_step = tracker_call_out_and_dispose;
    375         tracker_schedule(instance);
     374        instance->next_step = batch_call_out_and_dispose;
     375        batch_schedule(instance);
    376376}
    377377/**

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

    r7dd3318 r83c439c  
    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>
    … …  
    4848} dev_speed_t;
    4949
    50 typedef struct tracker
     50typedef struct batch
    5151{
    5252        link_t link;
    … …  
    7171        queue_head_t *qh;
    7272        transfer_descriptor_t *tds;
    73         void (*next_step)(struct tracker*);
    74 } tracker_t;
     73        void (*next_step)(struct batch*);
     74} batch_t;
    7575
    76 tracker_t * tracker_get(device_t *dev, usb_target_t target,
     76batch_t * batch_get(device_t *dev, usb_target_t target,
    7777    usb_transfer_type_t transfer_type, size_t max_packet_size,
    7878    dev_speed_t speed, char *buffer, size_t size,
    … …  
    8181    usbhc_iface_transfer_out_callback_t func_out, void *arg);
    8282
    83 bool tracker_is_complete(tracker_t *instance);
     83bool batch_is_complete(batch_t *instance);
    8484
    85 void tracker_control_write(tracker_t *instance);
     85void batch_control_write(batch_t *instance);
    8686
    87 void tracker_control_read(tracker_t *instance);
     87void batch_control_read(batch_t *instance);
    8888
    89 void tracker_interrupt_in(tracker_t *instance);
     89void batch_interrupt_in(batch_t *instance);
    9090
    91 void tracker_interrupt_out(tracker_t *instance);
     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

    r7dd3318 r83c439c  
    109109        dev_speed_t speed = FULL_SPEED;
    110110
    111         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_INTERRUPT,
     111        batch_t *batch = batch_get(dev, target, USB_TRANSFER_INTERRUPT,
    112112            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
    113         if (!tracker)
    114                 return ENOMEM;
    115         tracker_interrupt_out(tracker);
     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,
     126        batch_t *batch = batch_get(dev, target, USB_TRANSFER_INTERRUPT,
    127127            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
    128         if (!tracker)
    129                 return ENOMEM;
    130         tracker_interrupt_in(tracker);
     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,
     141        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    142142            max_packet_size, speed, data, size, setup_data, setup_size,
    143143            NULL, callback, arg);
    144         if (!tracker)
    145                 return ENOMEM;
    146         tracker_control_write(tracker);
     144        if (!batch)
     145                return ENOMEM;
     146        batch_control_write(batch);
    147147        return EOK;
    148148}
    … …  
    155155        dev_speed_t speed = FULL_SPEED;
    156156
    157         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     157        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    158158            max_packet_size, speed, data, size, setup_data, setup_size, callback,
    159159            NULL, arg);
    160         if (!tracker)
    161                 return ENOMEM;
    162         tracker_control_read(tracker);
     160        if (!batch)
     161                return ENOMEM;
     162        batch_control_read(batch);
    163163        return EOK;
    164164}
    … …  
    172172
    173173        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    174         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     174        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    175175            max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
    176         if (!tracker)
    177                 return ENOMEM;
    178         tracker_control_setup_old(tracker);
     176        if (!batch)
     177                return ENOMEM;
     178        batch_control_setup_old(batch);
    179179        return EOK;
    180180}
    … …  
    188188
    189189        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    190         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     190        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    191191            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg);
    192         if (!tracker)
    193                 return ENOMEM;
    194         tracker_control_write_data_old(tracker);
     192        if (!batch)
     193                return ENOMEM;
     194        batch_control_write_data_old(batch);
    195195        return EOK;
    196196}
    … …  
    203203
    204204        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    205         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     205        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    206206            max_packet_size, speed, NULL, 0, NULL, 0, callback, NULL, arg);
    207         if (!tracker)
    208                 return ENOMEM;
    209         tracker_control_write_status_old(tracker);
     207        if (!batch)
     208                return ENOMEM;
     209        batch_control_write_status_old(batch);
    210210        return EOK;
    211211}
    … …  
    219219
    220220        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    221         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     221        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    222222            max_packet_size, speed, NULL, 0, data, size, NULL, callback, arg);
    223         if (!tracker)
    224                 return ENOMEM;
    225         tracker_control_setup_old(tracker);
     223        if (!batch)
     224                return ENOMEM;
     225        batch_control_setup_old(batch);
    226226        return EOK;
    227227}
    … …  
    235235
    236236        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    237         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     237        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    238238            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg);
    239         if (!tracker)
    240                 return ENOMEM;
    241         tracker_control_read_data_old(tracker);
     239        if (!batch)
     240                return ENOMEM;
     241        batch_control_read_data_old(batch);
    242242        return EOK;
    243243}
    … …  
    250250
    251251        usb_log_warning("Using deprecated API %s.\n", __FUNCTION__);
    252         tracker_t *tracker = tracker_get(dev, target, USB_TRANSFER_CONTROL,
     252        batch_t *batch = batch_get(dev, target, USB_TRANSFER_CONTROL,
    253253            max_packet_size, speed, NULL, 0, NULL, 0, NULL, callback, arg);
    254         if (!tracker)
    255                 return ENOMEM;
    256         tracker_control_read_status_old(tracker);
     254        if (!batch)
     255                return ENOMEM;
     256        batch_control_read_status_old(batch);
    257257        return EOK;
    258258}

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

    r7dd3318 r83c439c  
    5151
    5252        queue_head_init(instance->queue_head);
    53         list_initialize(&instance->tracker_list);
     53        list_initialize(&instance->batch_list);
    5454        return EOK;
    5555}
    … …  
    6464}
    6565/*----------------------------------------------------------------------------*/
    66 void transfer_list_add_tracker(transfer_list_t *instance, tracker_t *tracker)
     66void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch)
    6767{
    6868        assert(instance);
    69         assert(tracker);
     69        assert(batch);
    7070
    71         uint32_t pa = (uintptr_t)addr_to_phys(tracker->qh);
     71        uint32_t pa = (uintptr_t)addr_to_phys(batch->qh);
    7272        assert((pa & LINK_POINTER_ADDRESS_MASK) == pa);
    7373        pa |= LINK_POINTER_QUEUE_HEAD_FLAG;
    … …  
    7676        if ((instance->queue_head->element & LINK_POINTER_TERMINATE_FLAG) != 0) {
    7777                /* there is nothing scheduled */
    78                 list_append(&tracker->link, &instance->tracker_list);
     78                list_append(&batch->link, &instance->batch_list);
    7979                instance->queue_head->element = pa;
    80                 usb_log_debug2("Added tracker(%p) to queue %s first.\n",
    81                         tracker, instance->name);
     80                usb_log_debug2("Added batch(%p) to queue %s first.\n",
     81                        batch, instance->name);
    8282                return;
    8383        }
    8484        /* now we can be sure that there is someting scheduled */
    85         assert(!list_empty(&instance->tracker_list));
    86         tracker_t *first = list_get_instance(
    87                   instance->tracker_list.next, tracker_t, link);
    88         tracker_t *last = list_get_instance(
    89             instance->tracker_list.prev, tracker_t, link);
     85        assert(!list_empty(&instance->batch_list));
     86        batch_t *first = list_get_instance(
     87                  instance->batch_list.next, batch_t, link);
     88        batch_t *last = list_get_instance(
     89            instance->batch_list.prev, batch_t, link);
    9090        queue_head_append_qh(last->qh, pa);
    91         list_append(&tracker->link, &instance->tracker_list);
    92         usb_log_debug2("Added tracker(%p) to queue %s last, first is %p.\n",
    93                 tracker, instance->name, first );
     91        list_append(&batch->link, &instance->batch_list);
     92        usb_log_debug2("Added batch(%p) to queue %s last, first is %p.\n",
     93                batch, instance->name, first );
    9494}
    9595/*----------------------------------------------------------------------------*/
    96 static void transfer_list_remove_tracker(
    97     transfer_list_t *instance, tracker_t *tracker)
     96static void transfer_list_remove_batch(
     97    transfer_list_t *instance, batch_t *batch)
    9898{
    9999        assert(instance);
    100         assert(tracker);
     100        assert(batch);
    101101        assert(instance->queue_head);
    102         assert(tracker->qh);
     102        assert(batch->qh);
    103103
    104104        /* I'm the first one here */
    105         if (tracker->link.next == &instance->tracker_list) {
     105        if (batch->link.next == &instance->batch_list) {
    106106                usb_log_debug("Removing tracer %p was first, next element %x.\n",
    107                         tracker, tracker->qh->next_queue);
    108                 instance->queue_head->element = tracker->qh->next_queue;
     107                        batch, batch->qh->next_queue);
     108                instance->queue_head->element = batch->qh->next_queue;
    109109        } else {
    110110                usb_log_debug("Removing tracer %p was NOT first, next element %x.\n",
    111                         tracker, tracker->qh->next_queue);
    112                 tracker_t *prev = list_get_instance(tracker->link.prev, tracker_t, link);
    113                 prev->qh->next_queue = tracker->qh->next_queue;
     111                        batch, batch->qh->next_queue);
     112                batch_t *prev = list_get_instance(batch->link.prev, batch_t, link);
     113                prev->qh->next_queue = batch->qh->next_queue;
    114114        }
    115         list_remove(&tracker->link);
     115        list_remove(&batch->link);
    116116}
    117117/*----------------------------------------------------------------------------*/
    … …  
    119119{
    120120        assert(instance);
    121         link_t *current = instance->tracker_list.next;
    122         while (current != &instance->tracker_list) {
     121        link_t *current = instance->batch_list.next;
     122        while (current != &instance->batch_list) {
    123123                link_t *next = current->next;
    124                 tracker_t *tracker = list_get_instance(current, tracker_t, link);
     124                batch_t *batch = list_get_instance(current, batch_t, link);
    125125
    126                 if (tracker_is_complete(tracker)) {
    127                         transfer_list_remove_tracker(instance, tracker);
    128                         tracker->next_step(tracker);
     126                if (batch_is_complete(batch)) {
     127                        transfer_list_remove_batch(instance, batch);
     128                        batch->next_step(batch);
    129129                }
    130130                current = next;

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

    r7dd3318 r83c439c  
    3737#include "uhci_struct/queue_head.h"
    3838
    39 #include "tracker.h"
     39#include "batch.h"
    4040
    4141typedef struct transfer_list
    … …  
    4545        struct transfer_list *next;
    4646        const char *name;
    47         link_t tracker_list;
     47        link_t batch_list;
    4848} transfer_list_t;
    4949
    … …  
    6060void transfer_list_check(transfer_list_t *instance);
    6161
    62 void transfer_list_add_tracker(transfer_list_t *instance, tracker_t *tracker);
     62void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);
    6363#endif
    6464/**

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

    r7dd3318 r83c439c  
    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->max_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->max_packet_size);
     162                          low_speed ? "LOW" : "FULL" , batch->transfer_type,
     163                    batch->max_packet_size);
    164164                return ENOTSUP;
    165165        }
    … …  
    167167
    168168        transfer_list_t *list =
    169             instance->transfers[low_speed][tracker->transfer_type];
     169            instance->transfers[low_speed][batch->transfer_type];
    170170        assert(list);
    171         transfer_list_add_tracker(list, tracker);
     171        transfer_list_add_batch(list, batch);
    172172
    173173        return EOK;

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

    r7dd3318 r83c439c  
    4444
    4545#include "transfer_list.h"
    46 #include "tracker.h"
     46#include "batch.h"
    4747
    4848typedef struct uhci_regs {
    … …  
    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)
Note: See TracChangeset for help on using the changeset viewer.