Changes in / [26d46d2:c7bdfa7] in mainline


Ignore:
Location:
uspace/drv
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/batch.c

    r26d46d2 rc7bdfa7  
    5151static void batch_control(usb_transfer_batch_t *instance,
    5252    usb_direction_t data_dir, usb_direction_t status_dir);
    53 static void batch_data(usb_transfer_batch_t *instance);
    5453static void batch_call_in_and_dispose(usb_transfer_batch_t *instance);
    5554static void batch_call_out_and_dispose(usb_transfer_batch_t *instance);
    … …  
    135134        assert(data);
    136135        size_t tds = data->td_count - 1;
    137         usb_log_debug("Batch(%p) checking %d td(s) for completion.\n",
     136        usb_log_debug2("Batch(%p) checking %d td(s) for completion.\n",
    138137            instance, tds);
    139         usb_log_debug("ED: %x:%x:%x:%x.\n",
    140             data->ed->status, data->ed->td_head, data->ed->td_tail,
    141             data->ed->next);
    142138        size_t i = 0;
    143139        for (; i < tds; ++i) {
    144                 usb_log_debug("TD %d: %x:%x:%x:%x.\n", i,
    145                     data->tds[i].status, data->tds[i].cbp, data->tds[i].next,
    146                     data->tds[i].be);
    147140                if (!td_is_finished(&data->tds[i]))
    148141                        return false;
    … …  
    184177        assert(instance->direction == USB_DIRECTION_IN);
    185178        instance->next_step = batch_call_in_and_dispose;
    186         batch_data(instance);
     179        /* TODO: implement */
    187180        usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
    188181}
    … …  
    196189            instance->buffer_size);
    197190        instance->next_step = batch_call_out_and_dispose;
    198         batch_data(instance);
     191        /* TODO: implement */
    199192        usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
    200193}
    … …  
    205198        instance->direction = USB_DIRECTION_IN;
    206199        instance->next_step = batch_call_in_and_dispose;
    207         batch_data(instance);
     200        /* TODO: implement */
    208201        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
    209202}
    … …  
    214207        instance->direction = USB_DIRECTION_IN;
    215208        instance->next_step = batch_call_in_and_dispose;
    216         batch_data(instance);
     209        /* TODO: implement */
    217210        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
    218211}
    … …  
    275268}
    276269/*----------------------------------------------------------------------------*/
    277 void batch_data(usb_transfer_batch_t *instance)
    278 {
    279         assert(instance);
    280         ohci_batch_t *data = instance->private_data;
    281         assert(data);
    282         ed_init(data->ed, instance->ep);
    283         ed_add_tds(data->ed, &data->tds[0], &data->tds[data->td_count - 1]);
    284         usb_log_debug("Created ED(%p): %x:%x:%x:%x.\n", data->ed,
    285             data->ed->status, data->ed->td_tail, data->ed->td_head,
    286             data->ed->next);
    287 
    288         /* data stage */
    289         size_t td_current = 1;
    290         size_t remain_size = instance->buffer_size;
    291         char *transfer_buffer = instance->transport_buffer;
    292         while (remain_size > 0) {
    293                 size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
    294                     OHCI_TD_MAX_TRANSFER : remain_size;
    295 
    296                 td_init(&data->tds[td_current], instance->ep->direction,
    297                     transfer_buffer, transfer_size, -1);
    298                 td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
    299                 usb_log_debug("Created DATA TD: %x:%x:%x:%x.\n",
    300                     data->tds[td_current].status, data->tds[td_current].cbp,
    301                     data->tds[td_current].next, data->tds[td_current].be);
    302 
    303                 transfer_buffer += transfer_size;
    304                 remain_size -= transfer_size;
    305                 assert(td_current < data->td_count);
    306                 ++td_current;
    307         }
    308 }
    309 /*----------------------------------------------------------------------------*/
    310270/** Helper function calls callback and correctly disposes of batch structure.
    311271 *

  • uspace/drv/ohci/hc.c

    r26d46d2 rc7bdfa7  
    135135        }
    136136
     137        transfer_list_add_batch(
     138            instance->transfers[batch->transfer_type], batch);
     139
    137140        switch (batch->transfer_type) {
    138141        case USB_TRANSFER_CONTROL:
    139142                instance->registers->control &= ~C_CLE;
    140                 transfer_list_add_batch(
    141                     instance->transfers[batch->transfer_type], batch);
    142143                instance->registers->command_status |= CS_CLF;
    143                 usb_log_debug2("Set CS control transfer filled: %x.\n",
     144                usb_log_debug2("Set control transfer filled: %x.\n",
    144145                        instance->registers->command_status);
    145                 instance->registers->control_current = 0;
    146146                instance->registers->control |= C_CLE;
    147147                break;
    148148        case USB_TRANSFER_BULK:
    149                 instance->registers->control &= ~C_BLE;
    150                 transfer_list_add_batch(
    151                     instance->transfers[batch->transfer_type], batch);
    152149                instance->registers->command_status |= CS_BLF;
    153150                usb_log_debug2("Set bulk transfer filled: %x.\n",
    154151                        instance->registers->command_status);
    155                 instance->registers->control |= C_BLE;
    156                 break;
    157         case USB_TRANSFER_INTERRUPT:
    158         case USB_TRANSFER_ISOCHRONOUS:
    159                 instance->registers->control &= ~C_PLE;
    160                 transfer_list_add_batch(
    161                     instance->transfers[batch->transfer_type], batch);
    162                 instance->registers->control |= C_PLE;
    163152                break;
    164153        default:
    … …  
    176165                rh_interrupt(&instance->rh);
    177166
    178         usb_log_debug("OHCI interrupt: %x.\n", status);
    179 
    180 
    181         if (status & IS_WDH) {
    182                 LIST_INITIALIZE(done);
    183                 transfer_list_remove_finished(
    184                     &instance->transfers_interrupt, &done);
    185                 transfer_list_remove_finished(
    186                     &instance->transfers_isochronous, &done);
    187                 transfer_list_remove_finished(
    188                     &instance->transfers_control, &done);
    189                 transfer_list_remove_finished(
    190                     &instance->transfers_bulk, &done);
    191 
    192                 while (!list_empty(&done)) {
    193                         link_t *item = done.next;
    194                         list_remove(item);
    195                         usb_transfer_batch_t *batch =
    196                             list_get_instance(item, usb_transfer_batch_t, link);
    197                         usb_transfer_batch_finish(batch);
    198                 }
     167        usb_log_info("OHCI interrupt: %x.\n", status);
     168
     169
     170        LIST_INITIALIZE(done);
     171        transfer_list_remove_finished(&instance->transfers_interrupt, &done);
     172        transfer_list_remove_finished(&instance->transfers_isochronous, &done);
     173        transfer_list_remove_finished(&instance->transfers_control, &done);
     174        transfer_list_remove_finished(&instance->transfers_bulk, &done);
     175
     176        while (!list_empty(&done)) {
     177                link_t *item = done.next;
     178                list_remove(item);
     179                usb_transfer_batch_t *batch =
     180                    list_get_instance(item, usb_transfer_batch_t, link);
     181                usb_transfer_batch_finish(batch);
    199182        }
    200183}
    … …  
    208191                instance->registers->interrupt_status = status;
    209192                hc_interrupt(instance, status);
    210                 async_usleep(10000);
     193                async_usleep(1000);
    211194        }
    212195        return EOK;
    … …  
    284267            instance->registers->control);
    285268
    286         /* Use HCCA */
    287         instance->registers->hcca = addr_to_phys(instance->hcca);
    288 
    289         /* Use queues */
    290         instance->registers->bulk_head = instance->transfers_bulk.list_head_pa;
    291         usb_log_debug2("Bulk HEAD set to: %p(%p).\n",
    292             instance->transfers_bulk.list_head,
    293             instance->transfers_bulk.list_head_pa);
    294 
    295         instance->registers->control_head =
    296             instance->transfers_control.list_head_pa;
    297         usb_log_debug2("Control HEAD set to: %p(%p).\n",
    298             instance->transfers_control.list_head,
    299             instance->transfers_control.list_head_pa);
    300 
    301269        /* Enable queues */
    302270        instance->registers->control |= (C_PLE | C_IE | C_CLE | C_BLE);
    … …  
    374342                return ENOMEM;
    375343        bzero(instance->hcca, sizeof(hcca_t));
    376         usb_log_debug2("OHCI HCCA initialized at %p.\n", instance->hcca);
     344        instance->registers->hcca = addr_to_phys(instance->hcca);
     345        usb_log_debug2("OHCI HCCA initialized at %p(%p).\n",
     346            instance->hcca, instance->registers->hcca);
     347
     348        /* Use queues */
     349        instance->registers->bulk_head = instance->transfers_bulk.list_head_pa;
     350        usb_log_debug2("Bulk HEAD set to: %p(%p).\n",
     351            instance->transfers_bulk.list_head,
     352            instance->transfers_bulk.list_head_pa);
     353
     354        instance->registers->control_head =
     355            instance->transfers_control.list_head_pa;
     356        usb_log_debug2("Control HEAD set to: %p(%p).\n",
     357            instance->transfers_control.list_head,
     358            instance->transfers_control.list_head_pa);
    377359
    378360        unsigned i = 0;

  • uspace/drv/ohci/hw_struct/endpoint_descriptor.c

    r26d46d2 rc7bdfa7  
    5353                << ED_STATUS_MPS_SHIFT);
    5454
    55 
    5655        if (ep->speed == USB_SPEED_LOW)
    5756                instance->status |= ED_STATUS_S_FLAG;
    5857        if (ep->transfer_type == USB_TRANSFER_ISOCHRONOUS)
    5958                instance->status |= ED_STATUS_F_FLAG;
    60 
    61         if (ep->toggle)
    62                 instance->td_head |= ED_TDHEAD_TOGGLE_CARRY;
    6359}
    6460/**

  • uspace/drv/ohci/hw_struct/endpoint_descriptor.h

    r26d46d2 rc7bdfa7  
    5353#define ED_STATUS_D_MASK (0x3)     /* direction */
    5454#define ED_STATUS_D_SHIFT (11)
    55 #define ED_STATUS_D_OUT (0x1)
    56 #define ED_STATUS_D_IN (0x2)
     55#define ED_STATUS_D_IN (0x1)
     56#define ED_STATUS_D_OUT (0x2)
    5757#define ED_STATUS_D_TRANSFER (0x3)
    5858
    … …  
    8484{
    8585        assert(instance);
    86         instance->td_head =
    87             ((addr_to_phys(head) & ED_TDHEAD_PTR_MASK)
    88             | (instance->td_head & ~ED_TDHEAD_PTR_MASK));
     86        instance->td_head = addr_to_phys(head) & ED_TDHEAD_PTR_MASK;
    8987        instance->td_tail = addr_to_phys(tail) & ED_TDTAIL_PTR_MASK;
    9088}
    … …  
    9896        instance->next = pa;
    9997}
     98
    10099#endif
    101100/**

  • uspace/drv/ohci/hw_struct/transfer_descriptor.h

    r26d46d2 rc7bdfa7  
    5050#define TD_STATUS_DP_SHIFT (19)
    5151#define TD_STATUS_DP_SETUP (0x0)
    52 #define TD_STATUS_DP_OUT (0x1)
    53 #define TD_STATUS_DP_IN (0x2)
     52#define TD_STATUS_DP_IN (0x1)
     53#define TD_STATUS_DP_OUT (0x2)
    5454#define TD_STATUS_DI_MASK (0x7) /* delay interrupt, wait DI frames before int */
    5555#define TD_STATUS_DI_SHIFT (21)

  • uspace/drv/ohci/main.c

    r26d46d2 rc7bdfa7  
    9292int main(int argc, char *argv[])
    9393{
    94         usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
     94        usb_log_enable(USB_LOG_LEVEL_DEFAULT, NAME);
    9595        sleep(5);
    9696        return ddf_driver_main(&ohci_driver);

  • uspace/drv/ohci/transfer_list.c

    r26d46d2 rc7bdfa7  
    143143
    144144        fibril_mutex_lock(&instance->guard);
    145         usb_log_debug2("Checking list %s for completed batches(%d).\n",
    146             instance->name, list_count(&instance->batch_list));
    147145        link_t *current = instance->batch_list.next;
    148146        while (current != &instance->batch_list) {
Note: See TracChangeset for help on using the changeset viewer.