Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/uhci-hcd/uhci.c

    ra7e2f0d r57c0a7e  
    6161};
    6262
    63 /** Gets USB address of the calling device.
    64  *
    65  * @param[in] fun UHCI hc function.
    66  * @param[in] handle Handle of the device seeking address.
    67  * @param[out] address Place to store found address.
    68  * @return Error code.
    69  */
    70 static int usb_iface_get_address(
    71     ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
     63static int usb_iface_get_address(ddf_fun_t *fun, devman_handle_t handle,
     64    usb_address_t *address)
    7265{
    7366        assert(fun);
     
    10699
    107100static bool allowed_usb_packet(
    108     bool low_speed, usb_transfer_type_t transfer, size_t size);
    109 /*----------------------------------------------------------------------------*/
    110 /** Initializes UHCI hcd driver structure
    111  *
    112  * @param[in] instance Memory place to initialize.
    113  * @param[in] dev DDF device.
    114  * @param[in] regs Address of I/O control registers.
    115  * @param[in] size Size of I/O control registers.
    116  * @return Error code.
    117  * @note Should be called only once on any structure.
    118  */
     101        bool low_speed, usb_transfer_type_t, size_t size);
     102
     103
    119104int uhci_init(uhci_t *instance, ddf_dev_t *dev, void *regs, size_t reg_size)
    120105{
     
    171156}
    172157/*----------------------------------------------------------------------------*/
    173 /** Initializes UHCI hcd hw resources.
    174  *
    175  * @param[in] instance UHCI structure to use.
    176  */
    177158void uhci_init_hw(uhci_t *instance)
    178159{
    179160        assert(instance);
    180         regs_t *registers = instance->registers;
    181 
    182         /* Reset everything, who knows what touched it before us */
    183         pio_write_16(&registers->usbcmd, UHCI_CMD_GLOBAL_RESET);
     161
     162        /* reset everything, who knows what touched it before us */
     163        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_GLOBAL_RESET);
    184164        async_usleep(10000); /* 10ms according to USB spec */
    185         pio_write_16(&registers->usbcmd, 0);
    186 
    187         /* Reset hc, all states and counters */
    188         pio_write_16(&registers->usbcmd, UHCI_CMD_HCRESET);
     165        pio_write_16(&instance->registers->usbcmd, 0);
     166
     167        /* reset hc, all states and counters */
     168        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_HCRESET);
    189169        do { async_usleep(10); }
    190         while ((pio_read_16(&registers->usbcmd) & UHCI_CMD_HCRESET) != 0);
    191 
    192         /* Set framelist pointer */
     170        while ((pio_read_16(&instance->registers->usbcmd) & UHCI_CMD_HCRESET) != 0);
     171
     172        /* set framelist pointer */
    193173        const uint32_t pa = addr_to_phys(instance->frame_list);
    194         pio_write_32(&registers->flbaseadd, pa);
    195 
    196         /* Enable all interrupts, but resume interrupt */
     174        pio_write_32(&instance->registers->flbaseadd, pa);
     175
     176        /* enable all interrupts, but resume interrupt */
    197177//      pio_write_16(&instance->registers->usbintr,
    198178//          UHCI_INTR_CRC | UHCI_INTR_COMPLETE | UHCI_INTR_SHORT_PACKET);
    199179
    200         uint16_t status = pio_read_16(&registers->usbcmd);
    201         if (status != 0)
    202                 usb_log_warning("Previous command value: %x.\n", status);
    203 
     180        uint16_t status = pio_read_16(&instance->registers->usbcmd);
     181        usb_log_warning("Previous command value: %x.\n", status);
    204182        /* Start the hc with large(64B) packet FSBR */
    205         pio_write_16(&registers->usbcmd,
     183        pio_write_16(&instance->registers->usbcmd,
    206184            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET | UHCI_CMD_CONFIGURE);
    207185}
    208186/*----------------------------------------------------------------------------*/
    209 /** Initializes UHCI hcd memory structures.
    210  *
    211  * @param[in] instance UHCI structure to use.
    212  * @return Error code
    213  * @note Should be called only once on any structure.
    214  */
    215187int uhci_init_mem_structures(uhci_t *instance)
    216188{
     
    224196        } else (void) 0
    225197
    226         /* Init interrupt code */
     198        /* init interrupt code */
    227199        instance->interrupt_code.cmds = malloc(sizeof(uhci_cmds));
    228200        int ret = (instance->interrupt_code.cmds == NULL) ? ENOMEM : EOK;
    229         CHECK_RET_DEST_CMDS_RETURN(ret,
    230             "Failed to allocate interrupt cmds space.\n");
     201        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to allocate interrupt cmds space.\n");
    231202
    232203        {
    233204                irq_cmd_t *interrupt_commands = instance->interrupt_code.cmds;
    234205                memcpy(interrupt_commands, uhci_cmds, sizeof(uhci_cmds));
    235                 interrupt_commands[0].addr =
    236                     (void*)&instance->registers->usbsts;
    237                 interrupt_commands[1].addr =
    238                     (void*)&instance->registers->usbsts;
     206                interrupt_commands[0].addr = (void*)&instance->registers->usbsts;
     207                interrupt_commands[1].addr = (void*)&instance->registers->usbsts;
    239208                instance->interrupt_code.cmdcount =
    240209                    sizeof(uhci_cmds) / sizeof(irq_cmd_t);
    241210        }
    242211
    243         /* Init transfer lists */
     212        /* init transfer lists */
    244213        ret = uhci_init_transfer_lists(instance);
    245         CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to init transfer lists.\n");
     214        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to initialize transfer lists.\n");
    246215        usb_log_debug("Initialized transfer lists.\n");
    247216
    248         /* Init USB frame list page*/
     217        /* frame list initialization */
    249218        instance->frame_list = get_page();
    250219        ret = instance ? EOK : ENOMEM;
     
    252221        usb_log_debug("Initialized frame list.\n");
    253222
    254         /* Set all frames to point to the first queue head */
     223        /* initialize all frames to point to the first queue head */
    255224        const uint32_t queue =
    256225          instance->transfers_interrupt.queue_head_pa
     
    262231        }
    263232
    264         /* Init device keeper*/
     233        /* init address keeper(libusb) */
    265234        device_keeper_init(&instance->device_manager);
    266235        usb_log_debug("Initialized device manager.\n");
     
    270239}
    271240/*----------------------------------------------------------------------------*/
    272 /** Initializes UHCI hcd transfer lists.
    273  *
    274  * @param[in] instance UHCI structure to use.
    275  * @return Error code
    276  * @note Should be called only once on any structure.
    277  */
    278241int uhci_init_transfer_lists(uhci_t *instance)
    279242{
     
    294257        CHECK_RET_CLEAR_RETURN(ret, "Failed to init BULK list.");
    295258
    296         ret = transfer_list_init(
    297             &instance->transfers_control_full, "CONTROL_FULL");
     259        ret = transfer_list_init(&instance->transfers_control_full, "CONTROL_FULL");
    298260        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL FULL list.");
    299261
    300         ret = transfer_list_init(
    301             &instance->transfers_control_slow, "CONTROL_SLOW");
     262        ret = transfer_list_init(&instance->transfers_control_slow, "CONTROL_SLOW");
    302263        CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL SLOW list.");
    303264
     
    318279#endif
    319280
    320         /* Assign pointers to be used during scheduling */
    321         instance->transfers[USB_SPEED_FULL][USB_TRANSFER_INTERRUPT] =
     281        instance->transfers[0][USB_TRANSFER_INTERRUPT] =
    322282          &instance->transfers_interrupt;
    323         instance->transfers[USB_SPEED_LOW][USB_TRANSFER_INTERRUPT] =
     283        instance->transfers[1][USB_TRANSFER_INTERRUPT] =
    324284          &instance->transfers_interrupt;
    325         instance->transfers[USB_SPEED_FULL][USB_TRANSFER_CONTROL] =
     285        instance->transfers[0][USB_TRANSFER_CONTROL] =
    326286          &instance->transfers_control_full;
    327         instance->transfers[USB_SPEED_LOW][USB_TRANSFER_CONTROL] =
     287        instance->transfers[1][USB_TRANSFER_CONTROL] =
    328288          &instance->transfers_control_slow;
    329         instance->transfers[USB_SPEED_FULL][USB_TRANSFER_BULK] =
     289        instance->transfers[0][USB_TRANSFER_BULK] =
    330290          &instance->transfers_bulk_full;
    331291
     
    334294}
    335295/*----------------------------------------------------------------------------*/
    336 /** Schedules batch for execution.
    337  *
    338  * @param[in] instance UHCI structure to use.
    339  * @param[in] batch Transfer batch to schedule.
    340  * @return Error code
    341  */
    342296int uhci_schedule(uhci_t *instance, batch_t *batch)
    343297{
     
    347301        if (!allowed_usb_packet(
    348302            low_speed, batch->transfer_type, batch->max_packet_size)) {
    349                 usb_log_warning(
    350                     "Invalid USB packet specified %s SPEED %d %zu.\n",
     303                usb_log_warning("Invalid USB packet specified %s SPEED %d %zu.\n",
    351304                    low_speed ? "LOW" : "FULL" , batch->transfer_type,
    352305                    batch->max_packet_size);
     
    363316}
    364317/*----------------------------------------------------------------------------*/
    365 /** Takes action based on the interrupt cause.
    366  *
    367  * @param[in] instance UHCI structure to use.
    368  * @param[in] status Value of the stsatus regiser at the time of interrupt.
    369  */
    370318void uhci_interrupt(uhci_t *instance, uint16_t status)
    371319{
    372320        assert(instance);
    373         /* TODO: Check interrupt cause here */
    374321        transfer_list_remove_finished(&instance->transfers_interrupt);
    375322        transfer_list_remove_finished(&instance->transfers_control_slow);
     
    378325}
    379326/*----------------------------------------------------------------------------*/
    380 /** Polling function, emulates interrupts.
    381  *
    382  * @param[in] arg UHCI structure to use.
    383  * @return EOK
    384  */
    385327int uhci_interrupt_emulator(void* arg)
    386328{
     
    401343}
    402344/*---------------------------------------------------------------------------*/
    403 /** Debug function, checks consistency of memory structures.
    404  *
    405  * @param[in] arg UHCI structure to use.
    406  * @return EOK
    407  */
    408345int uhci_debug_checker(void *arg)
    409346{
     
    464401                async_usleep(UHCI_DEBUGER_TIMEOUT);
    465402        }
    466         return EOK;
     403        return 0;
    467404#undef QH
    468405}
    469406/*----------------------------------------------------------------------------*/
    470 /** Checks transfer packets, for USB validity
    471  *
    472  * @param[in] low_speed Transfer speed.
    473  * @param[in] transfer Transer type
    474  * @param[in] size Maximum size of used packets
    475  * @return EOK
    476  */
    477407bool allowed_usb_packet(
    478408    bool low_speed, usb_transfer_type_t transfer, size_t size)
Note: See TracChangeset for help on using the changeset viewer.