Changes in / [54d9058:dc04868] in mainline


Ignore:
Location:
uspace/drv/uhci-hcd
Files:
2 added
2 deleted
10 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci-hcd/Makefile

    r54d9058 rdc04868  
    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

    r54d9058 rdc04868  
    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 %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);
    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        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);
    195187        return EOK;
    196188}
    … …  
    199191    usbhc_iface_transfer_in_callback_t callback, void *arg)
    200192{
    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);
     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);
    210199        return EOK;
    211200}
    … …  
    215204    usbhc_iface_transfer_out_callback_t callback, void *arg)
    216205{
    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);
     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);
    226212        return EOK;
    227213}
    … …  
    231217    usbhc_iface_transfer_in_callback_t callback, void *arg)
    232218{
    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);
     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);
    242225        return EOK;
    243226}
    … …  
    246229    usbhc_iface_transfer_out_callback_t callback, void *arg)
    247230{
    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);
     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);
    257237        return EOK;
    258238}

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

    r54d9058 rdc04868  
    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);
     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        }
    101101}
    102102/*----------------------------------------------------------------------------*/
    103 static void transfer_list_remove_batch(
    104     transfer_list_t *instance, batch_t *batch)
     103void transfer_list_remove_tracker(transfer_list_t *instance, tracker_t *tracker)
    105104{
    106105        assert(instance);
    107         assert(batch);
     106        assert(tracker);
    108107        assert(instance->queue_head);
    109         assert(batch->qh);
     108        assert(tracker->td);
    110109
    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;
     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;
    121113        }
    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);
    141114}
    142115/**

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

    r54d9058 rdc04868  
    3535#define DRV_UHCI_TRANSFER_LIST_H
    3636
    37 #include <fibril_synch.h>
    38 
    3937#include "uhci_struct/queue_head.h"
    4038
    41 #include "batch.h"
     39#include "tracker.h"
    4240
    4341typedef struct transfer_list
    4442{
    45         fibril_mutex_t guard;
     43        tracker_t *last_tracker;
     44
    4645        queue_head_t *queue_head;
    4746        uint32_t queue_head_pa;
    4847        struct transfer_list *next;
    4948        const char *name;
    50         link_t batch_list;
    5149} transfer_list_t;
    5250
    … …  
    5553void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next);
    5654
     55
    5756static inline void transfer_list_fini(transfer_list_t *instance)
    5857{
    … …  
    6059        queue_head_dispose(instance->queue_head);
    6160}
    62 void transfer_list_check(transfer_list_t *instance);
    6361
    64 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);
     62void transfer_list_add_tracker(transfer_list_t *instance, tracker_t *tracker);
     63
     64void transfer_list_remove_tracker(transfer_list_t *instance, tracker_t *track);
     65
    6566#endif
    6667/**

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

    r54d9058 rdc04868  
    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        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());
    172187
    173188        return EOK;
    … …  
    181196
    182197        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);
     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                }
    187240                async_usleep(UHCI_CLEANER_TIMEOUT);
    188241        }

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

    r54d9058 rdc04868  
    4444
    4545#include "transfer_list.h"
    46 #include "batch.h"
     46#include "tracker.h"
    4747
    4848typedef struct uhci_regs {
    … …  
    7272
    7373#define UHCI_FRAME_LIST_COUNT 1024
    74 #define UHCI_CLEANER_TIMEOUT 10000
     74#define UHCI_CLEANER_TIMEOUT 1000
    7575#define UHCI_DEBUGER_TIMEOUT 5000000
    7676
    … …  
    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

    r54d9058 rdc04868  
    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

    r54d9058 rdc04868  
    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

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

    r54d9058 rdc04868  
    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

    r54d9058 rdc04868  
    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
Note: See TracChangeset for help on using the changeset viewer.