Changes in / [709e868:501e5df] in mainline


Ignore:
Location:
uspace/drv
Files:
1 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/batch.c

    r709e868 r501e5df  
    227227        ed_init(data->ed, instance->ep);
    228228        ed_add_tds(data->ed, &data->tds[0], &data->tds[data->td_count - 1]);
    229         usb_log_debug("Created ED: %x:%x:%x:%x.\n", data->ed->status,
    230             data->ed->td_tail, data->ed->td_head, data->ed->next);
     229        usb_log_debug("Created ED(%p): %x:%x:%x:%x.\n", data->ed,
     230            data->ed->status, data->ed->td_tail, data->ed->td_head,
     231            data->ed->next);
    231232        int toggle = 0;
    232233        /* setup stage */

  • uspace/drv/ohci/hc.c

    r709e868 r501e5df  
    108108            ret, str_error(ret));
    109109
     110        hc_gain_control(instance);
     111        ret = hc_init_memory(instance);
     112        CHECK_RET_RETURN(ret, "Failed to create OHCI memory structures:%s.\n",
     113            ret, str_error(ret));
     114        hc_init_hw(instance);
     115
     116        rh_init(&instance->rh, dev, instance->registers);
     117
    110118        if (!interrupts) {
    111119                instance->interrupt_emulator =
    … …  
    114122        }
    115123
    116         hc_gain_control(instance);
    117 
    118         rh_init(&instance->rh, dev, instance->registers);
    119 
    120         hc_init_memory(instance);
    121         hc_init_hw(instance);
    122 
    123         /* TODO: implement */
    124124        return EOK;
    125125}
    … …  
    140140        switch (batch->transfer_type) {
    141141        case USB_TRANSFER_CONTROL:
     142                instance->registers->control &= ~C_CLE;
    142143                instance->registers->command_status |= CS_CLF;
     144                usb_log_debug2("Set control transfer filled: %x.\n",
     145                        instance->registers->command_status);
     146                instance->registers->control |= C_CLE;
    143147                break;
    144148        case USB_TRANSFER_BULK:
    145149                instance->registers->command_status |= CS_BLF;
     150                usb_log_debug2("Set bulk transfer filled: %x.\n",
     151                        instance->registers->command_status);
    146152                break;
    147153        default:
    … …  
    154160{
    155161        assert(instance);
    156         if (status == 0)
     162        if ((status & ~IS_SF) == 0) /* ignore sof status */
    157163                return;
    158164        if (status & IS_RHSC)
    … …  
    160166
    161167        usb_log_info("OHCI interrupt: %x.\n", status);
     168
    162169
    163170        LIST_INITIALIZE(done);
    … …  
    192199{
    193200        assert(instance);
     201        /* Turn off legacy emulation */
     202        volatile uint32_t *ohci_emulation_reg =
     203            (uint32_t*)((char*)instance->registers + 0x100);
     204        usb_log_debug("OHCI legacy register %p: %x.\n",
     205                ohci_emulation_reg, *ohci_emulation_reg);
     206        *ohci_emulation_reg = 0;
     207
    194208        /* Interrupt routing enabled => smm driver is active */
    195209        if (instance->registers->control & C_IR) {
    196                 usb_log_info("Found SMM driver requesting ownership change.\n");
     210                usb_log_debug("SMM driver: request ownership change.\n");
    197211                instance->registers->command_status |= CS_OCR;
    198212                while (instance->registers->control & C_IR) {
    199213                        async_usleep(1000);
    200214                }
    201                 usb_log_info("Ownership taken from SMM driver.\n");
     215                usb_log_info("SMM driver: Ownership taken.\n");
    202216                return;
    203217        }
    … …  
    207221        /* Interrupt routing disabled && status != USB_RESET => BIOS active */
    208222        if (hc_status != C_HCFS_RESET) {
    209                 usb_log_info("Found BIOS driver.\n");
     223                usb_log_debug("BIOS driver found.\n");
    210224                if (hc_status == C_HCFS_OPERATIONAL) {
    211                         usb_log_info("HC operational(BIOS).\n");
     225                        usb_log_info("BIOS driver: HC operational.\n");
    212226                        return;
    213227                }
    … …  
    215229                instance->registers->control &= (C_HCFS_RESUME << C_HCFS_SHIFT);
    216230                async_usleep(20000);
     231                usb_log_info("BIOS driver: HC resumed.\n");
    217232                return;
    218233        }
    … …  
    220235        /* HC is in reset (hw startup) => no other driver
    221236         * maintain reset for at least the time specified in USB spec (50 ms)*/
     237        usb_log_info("HC found in reset.\n");
    222238        async_usleep(50000);
    223 
    224         /* turn off legacy emulation */
    225         volatile uint32_t *ohci_emulation_reg =
    226             (uint32_t*)((char*)instance->registers + 0x100);
    227         usb_log_info("OHCI legacy register status %p: %x.\n",
    228                 ohci_emulation_reg, *ohci_emulation_reg);
    229         *ohci_emulation_reg = 0;
    230 
    231239}
    232240/*----------------------------------------------------------------------------*/
    233241void hc_init_hw(hc_t *instance)
    234242{
    235         assert(instance);
     243        /* OHCI guide page 42 */
     244        assert(instance);
     245        usb_log_debug2("Started hc initialization routine.\n");
     246
     247        /* Save contents of fm_interval register */
    236248        const uint32_t fm_interval = instance->registers->fm_interval;
    237 
    238         /* reset hc */
     249        usb_log_debug2("Old value of HcFmInterval: %x.\n", fm_interval);
     250
     251        /* Reset hc */
     252        usb_log_debug2("HC reset.\n");
     253        size_t time = 0;
    239254        instance->registers->command_status = CS_HCR;
    240         async_usleep(10);
    241 
    242         /* restore fm_interval */
     255        while (instance->registers->command_status & CS_HCR) {
     256                async_usleep(10);
     257                time += 10;
     258        }
     259        usb_log_debug2("HC reset complete in %zu us.\n", time);
     260
     261        /* Restore fm_interval */
    243262        instance->registers->fm_interval = fm_interval;
    244263        assert((instance->registers->command_status & CS_HCR) == 0);
    245264
    246265        /* hc is now in suspend state */
    247 
    248         /* enable queues */
     266        usb_log_debug2("HC should be in suspend state(%x).\n",
     267            instance->registers->control);
     268
     269        /* Enable queues */
    249270        instance->registers->control |= (C_PLE | C_IE | C_CLE | C_BLE);
    250         /* TODO: enable interrupts */
    251         /* set periodic start to 90% */
    252         instance->registers->periodic_start = (fm_interval / 10) * 9;
     271        usb_log_debug2("All queues enabled(%x).\n",
     272            instance->registers->control);
     273
     274        /* Disable interrupts */
     275        instance->registers->interrupt_disable = I_SF | I_OC;
     276        usb_log_debug2("Disabling interrupts: %x.\n",
     277            instance->registers->interrupt_disable);
     278        instance->registers->interrupt_disable = I_MI;
     279        usb_log_debug2("Enabled interrupts: %x.\n",
     280            instance->registers->interrupt_enable);
     281
     282        /* Set periodic start to 90% */
     283        uint32_t frame_length = ((fm_interval >> FMI_FI_SHIFT) & FMI_FI_MASK);
     284        instance->registers->periodic_start = (frame_length / 10) * 9;
     285        usb_log_debug2("All periodic start set to: %x(%u - 90%% of %d).\n",
     286            instance->registers->periodic_start,
     287            instance->registers->periodic_start, frame_length);
    253288
    254289        instance->registers->control &= (C_HCFS_OPERATIONAL << C_HCFS_SHIFT);
    255         usb_log_info("OHCI HC up and running.\n");
     290        usb_log_info("OHCI HC up and running(%x).\n",
     291            instance->registers->control);
    256292}
    257293/*----------------------------------------------------------------------------*/
    … …  
    298334{
    299335        assert(instance);
    300         /* init queues */
     336        /* Init queues */
    301337        hc_init_transfer_lists(instance);
    302338
    303         /* init HCCA */
     339        /*Init HCCA */
    304340        instance->hcca = malloc32(sizeof(hcca_t));
    305341        if (instance->hcca == NULL)
    … …  
    307343        bzero(instance->hcca, sizeof(hcca_t));
    308344        instance->registers->hcca = addr_to_phys(instance->hcca);
    309 
    310         /* use queues */
     345        usb_log_debug2("OHCI HCCA initialized at %p(%p).\n",
     346            instance->hcca, instance->registers->hcca);
     347
     348        /* Use queues */
    311349        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
    312354        instance->registers->control_head =
    313355            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);
    314359
    315360        unsigned i = 0;
    … …  
    318363                    instance->transfers_interrupt.list_head_pa;
    319364        }
     365        usb_log_debug2("Interrupt HEADs set to: %p(%p).\n",
     366            instance->transfers_interrupt.list_head,
     367            instance->transfers_interrupt.list_head_pa);
    320368
    321369        return EOK;

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

    r709e868 r501e5df  
    4242        bzero(instance, sizeof(ed_t));
    4343        if (ep == NULL) {
    44                 instance->status |= ED_STATUS_K_FLAG;
     44                instance->status = ED_STATUS_K_FLAG;
    4545                return;
    4646        }
    … …  
    5757        if (ep->transfer_type == USB_TRANSFER_ISOCHRONOUS)
    5858                instance->status |= ED_STATUS_F_FLAG;
    59 
    6059}
    61 
    6260/**
    6361 * @}

  • uspace/drv/ohci/ohci_regs.h

    r709e868 r501e5df  
    8484        /** Interupt enable/disable, reads give the same value, writing causes
    8585         * enable/disable */
    86         volatile uint32_t interupt_enable;
     86        volatile uint32_t interrupt_enable;
    8787        volatile uint32_t interrupt_disable;
    8888#define I_SO   (1 << 0)   /* Scheduling overrun */
    … …  
    120120        /** Frame time and max packet size for all transfers */
    121121        volatile uint32_t fm_interval;
    122 #define FMI_FI_MASK (0x1fff) /* Frame interval in bit times (should be 11999)*/
     122#define FMI_FI_MASK (0x3fff) /* Frame interval in bit times (should be 11999)*/
    123123#define FMI_FI_SHIFT (0)
    124124#define FMI_FSMPS_MASK (0x7fff) /* Full speed max packet size */
    … …  
    138138        /** Remaining bit time in frame to start periodic transfers */
    139139        volatile uint32_t periodic_start;
    140 #define PS_PS_MASK (0x1fff) /* bit time when periodic get priority (0x3e67) */
     140#define PS_PS_MASK (0x3fff) /* bit time when periodic get priority (0x3e67) */
    141141
    142142        /** Threshold for starting LS transaction */

  • uspace/drv/ohci/root_hub.c

    r709e868 r501e5df  
    210210        instance->registers = regs;
    211211        instance->device = dev;
    212         instance->port_count = instance->registers->rh_desc_a & 0xff;
     212        instance->port_count =
     213            (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK;
    213214        rh_init_descriptors(instance);
    214215        // set port power mode to no-power-switching

  • uspace/drv/ohci/transfer_list.c

    r709e868 r501e5df  
    122122        usb_transfer_batch_t *first = list_get_instance(
    123123            instance->batch_list.next, usb_transfer_batch_t, link);
    124         usb_log_debug("Batch(%p) added to queue %s, first is %p.\n",
    125                 batch, instance->name, first);
     124        usb_log_debug("Batch(%p) added to list %s, first is %p(%p).\n",
     125                batch, instance->name, first, batch_ed(first));
     126        if (last_ed == instance->list_head) {
     127                usb_log_debug2("%s head ED: %x:%x:%x:%x.\n", instance->name,
     128                        last_ed->status, last_ed->td_tail, last_ed->td_head,
     129                        last_ed->next);
     130        }
    126131        fibril_mutex_unlock(&instance->guard);
    127132}
Note: See TracChangeset for help on using the changeset viewer.