Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 881c47b in mainline for uspace/drv/uhci-hcd/uhci.c


Ignore:
Timestamp:
2011-02-04T14:45:42Z (12 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial
Children:
dcef366
Parents:
97e87de
Message:

New UHCI packet scheduler

queues are named for nicer debug output
slow_speed is set by iface functions

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r97e87de r881c47b  
    3939#include "uhci.h"
    4040
    41 static int uhci_init_transfer_lists(transfer_list_t list[]);
     41static int uhci_init_transfer_lists(uhci_t *instance);
    4242static int uhci_clean_finished(void *arg);
    4343static int uhci_debug_checker(void *arg);
    … …  
    6464
    6565        /* init transfer lists */
    66         ret = uhci_init_transfer_lists(instance->transfers);
     66        ret = uhci_init_transfer_lists(instance);
    6767        CHECK_RET_RETURN("Failed to initialize transfer lists.\n");
    6868        usb_log_debug("Transfer lists initialized.\n");
    … …  
    7676        /* initialize all frames to point to the first queue head */
    7777        const uint32_t queue =
    78           instance->transfers[USB_TRANSFER_INTERRUPT].queue_head_pa
     78          instance->transfers_interrupt.queue_head_pa
    7979          | LINK_POINTER_QUEUE_HEAD_FLAG;
    8080        unsigned i = 0;
    … …  
    9797            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET);
    9898        usb_log_debug("Started UHCI HC.\n");
    99 /*
     99
    100100        uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
    101101        cmd |= UHCI_CMD_DEBUG;
    102102        pio_write_16(&instance->registers->usbcmd, cmd);
    103 */
     103
    104104        return EOK;
    105105}
    106106/*----------------------------------------------------------------------------*/
    107 int uhci_init_transfer_lists(transfer_list_t transfers[])
    108 {
    109         //TODO:refactor
    110         transfers[USB_TRANSFER_ISOCHRONOUS].first = NULL;
    111         transfers[USB_TRANSFER_ISOCHRONOUS].last = NULL;
    112 
     107int uhci_init_transfer_lists(uhci_t *instance)
     108{
     109        assert(instance);
     110
     111        /* initialize */
    113112        int ret;
    114         ret = transfer_list_init(&transfers[USB_TRANSFER_BULK], NULL);
    115         if (ret != EOK) {
    116                 usb_log_error("Failed to initialize bulk queue.\n");
    117                 return ret;
    118         }
    119 
    120         ret = transfer_list_init(
    121           &transfers[USB_TRANSFER_CONTROL], &transfers[USB_TRANSFER_BULK]);
    122         if (ret != EOK) {
    123                 usb_log_error("Failed to initialize control queue.\n");
    124                 transfer_list_fini(&transfers[USB_TRANSFER_BULK]);
    125                 return ret;
    126         }
    127 
    128         ret = transfer_list_init(
    129           &transfers[USB_TRANSFER_INTERRUPT], &transfers[USB_TRANSFER_CONTROL]);
    130         if (ret != EOK) {
    131                 usb_log_error("Failed to initialize interrupt queue.\n");
    132                 transfer_list_fini(&transfers[USB_TRANSFER_CONTROL]);
    133                 transfer_list_fini(&transfers[USB_TRANSFER_BULK]);
    134                 return ret;
    135         }
     113        ret = transfer_list_init(&instance->transfers_bulk_full, "BULK_FULL");
     114        assert(ret == EOK);
     115        ret = transfer_list_init(&instance->transfers_control_full, "CONTROL_FULL");
     116        assert(ret == EOK);
     117        ret = transfer_list_init(&instance->transfers_control_slow, "CONTROL_SLOW");
     118        assert(ret == EOK);
     119        ret = transfer_list_init(&instance->transfers_interrupt, "INTERRUPT");
     120        assert(ret == EOK);
     121
     122        transfer_list_set_next(&instance->transfers_control_full,
     123                &instance->transfers_bulk_full);
     124        transfer_list_set_next(&instance->transfers_control_slow,
     125                &instance->transfers_control_full);
     126        transfer_list_set_next(&instance->transfers_interrupt,
     127                &instance->transfers_control_slow);
     128
     129        /*FSBR*/
     130#ifdef FSBR
     131        transfer_list_set_next(&instance->transfers_bulk_full,
     132                &instance->transfers_control_full);
     133#endif
     134
     135        instance->transfers[0][USB_TRANSFER_INTERRUPT] =
     136          &instance->transfers_interrupt;
     137        instance->transfers[1][USB_TRANSFER_INTERRUPT] =
     138          &instance->transfers_interrupt;
     139        instance->transfers[0][USB_TRANSFER_CONTROL] =
     140          &instance->transfers_control_full;
     141        instance->transfers[1][USB_TRANSFER_CONTROL] =
     142          &instance->transfers_control_slow;
     143        instance->transfers[0][USB_TRANSFER_CONTROL] =
     144          &instance->transfers_control_full;
    136145
    137146        return EOK;
    … …  
    145154        bool toggle,
    146155  usb_packet_id pid,
     156        bool low_speed,
    147157  void *buffer, size_t size,
    148158  usbhc_iface_transfer_out_callback_t callback_out,
    … …  
    165175        if (size >= 1024) {
    166176                usb_log_warning("Transfer too big.\n");
     177                return ENOTSUP;
     178        }
     179        transfer_list_t *list = instance->transfers[low_speed][transfer_type];
     180        if (!list) {
     181                usb_log_warning("UNSUPPORTED transfer %d-%d.\n", low_speed, transfer_type);
    167182                return ENOTSUP;
    168183        }
    … …  
    193208        td->callback = job;
    194209
    195         usb_log_debug("Appending a new transfer to queue.\n");
    196         ret = transfer_list_append(&instance->transfers[transfer_type], td);
     210
     211        usb_log_debug("Appending a new transfer to queue %s.\n", list->name);
     212
     213        ret = transfer_list_append(list, td);
    197214        CHECK_RET_TRANS_FREE_JOB_TD("Failed to append transfer descriptor.\n");
    198215
    … …  
    209226                usb_log_debug("Running cleaning fibril on: %p.\n", instance);
    210227                /* iterate all transfer queues */
    211                 int i = 0;
    212                 for (; i < TRANSFER_QUEUES; ++i) {
     228                transfer_list_t *current_list = &instance->transfers_interrupt;
     229                while (current_list) {
    213230                        /* Remove inactive transfers from the top of the queue
    214231                         * TODO: should I reach queue head or is this enough? */
    215232                        volatile transfer_descriptor_t * it =
    216                                 instance->transfers[i].first;
    217                         usb_log_debug("Running cleaning fibril on queue: %p (%s).\n",
    218                                 &instance->transfers[i], it ? "SOMETHING" : "EMPTY");
     233                                current_list->first;
     234                        usb_log_debug("Running cleaning fibril on queue: %s (%s).\n",
     235                                current_list->name, it ? "SOMETHING" : "EMPTY");
    219236
    220237                        if (it)
    … …  
    222239                                        it, it->status);
    223240
    224                         while (instance->transfers[i].first &&
    225                          !(instance->transfers[i].first->status & TD_STATUS_ERROR_ACTIVE)) {
    226                                 transfer_descriptor_t *transfer = instance->transfers[i].first;
     241                        while (current_list->first &&
     242                         !(current_list->first->status & TD_STATUS_ERROR_ACTIVE)) {
     243                                transfer_descriptor_t *transfer = current_list->first;
    227244                                usb_log_info("Inactive transfer calling callback with status %x.\n",
    228245                                  transfer->status);
    229                                 instance->transfers[i].first = transfer->next_va;
     246                                current_list->first = transfer->next_va;
    230247                                transfer_descriptor_dispose(transfer);
    231248                        }
    232                         if (!instance->transfers[i].first)
    233                                 instance->transfers[i].last = instance->transfers[i].first;
     249                        if (!current_list->first)
     250                                current_list->last = current_list->first;
     251
     252                        current_list = current_list->next;
    234253                }
    235254                async_usleep(UHCI_CLEANER_TIMEOUT);
    … …  
    246265                uint16_t sts = pio_read_16(&instance->registers->usbsts);
    247266                usb_log_debug("Command register: %X Status register: %X\n", cmd, sts);
    248 /*
     267
    249268                uintptr_t frame_list = pio_read_32(&instance->registers->flbaseadd);
    250269                usb_log_debug("Framelist address: %p vs. %p.\n",
    … …  
    253272                usb_log_debug("Framelist item: %d \n", frnum );
    254273
    255                 queue_head_t* qh = instance->transfers[USB_TRANSFER_INTERRUPT].queue_head;
    256                 usb_log_debug("Interrupt QH: %p vs. %p.\n",
    257                         instance->frame_list[frnum], addr_to_phys(qh));
    258 
    259                 usb_log_debug("Control QH: %p vs. %p.\n", qh->next_queue,
    260                         addr_to_phys(instance->transfers[USB_TRANSFER_CONTROL].queue_head));
    261                 qh = instance->transfers[USB_TRANSFER_CONTROL].queue_head;
    262 
    263                 usb_log_debug("Bulk QH: %p vs. %p.\n", qh->next_queue,
    264                         addr_to_phys(instance->transfers[USB_TRANSFER_BULK].queue_head));
     274                queue_head_t* qh = instance->transfers_interrupt.queue_head;
     275
     276                if ((instance->frame_list[frnum] & (~0xf)) != (uintptr_t)addr_to_phys(qh)) {
     277                        usb_log_debug("Interrupt QH: %p vs. %p.\n",
     278                                instance->frame_list[frnum] & (~0xf), addr_to_phys(qh));
     279                }
     280
     281                if ((qh->next_queue & (~0xf))
     282                  != (uintptr_t)addr_to_phys(instance->transfers_control_slow.queue_head)) {
     283                        usb_log_debug("Control Slow QH: %p vs. %p.\n", qh->next_queue & (~0xf),
     284                                addr_to_phys(instance->transfers_control_slow.queue_head));
     285                }
     286                qh = instance->transfers_control_slow.queue_head;
     287
     288                if ((qh->next_queue & (~0xf))
     289                  != (uintptr_t)addr_to_phys(instance->transfers_control_full.queue_head)) {
     290                        usb_log_debug("Control Full QH: %p vs. %p.\n", qh->next_queue & (~0xf),
     291                                addr_to_phys(instance->transfers_control_full.queue_head));\
     292                }
     293                qh = instance->transfers_control_full.queue_head;
     294
     295                if ((qh->next_queue & (~0xf))
     296                  != (uintptr_t)addr_to_phys(instance->transfers_bulk_full.queue_head)) {
     297                        usb_log_debug("Bulk QH: %p vs. %p.\n", qh->next_queue & (~0xf),
     298                                addr_to_phys(instance->transfers_bulk_full.queue_head));
     299                }
     300/*
    265301        uint16_t cmd = pio_read_16(&instance->registers->usbcmd);
    266302        cmd |= UHCI_CMD_RUN_STOP;
    267303        pio_write_16(&instance->registers->usbcmd, cmd);
    268304*/
    269 
    270305                async_usleep(UHCI_DEBUGER_TIMEOUT);
    271306        }
Note: See TracChangeset for help on using the changeset viewer.