Changes in uspace/drv/ohci/hc.c [8953514:3e4f2e0] in mainline


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • TabularUnified uspace/drv/ohci/hc.c

    r8953514 r3e4f2e0  
    5151static int hc_init_memory(hc_t *instance);
    5252/*----------------------------------------------------------------------------*/
    53 /** Announce OHCI root hub to the DDF
    54  *
    55  * @param[in] instance OHCI driver intance
    56  * @param[in] hub_fun DDF fuction representing OHCI root hub
    57  * @return Error code
    58  */
    5953int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun)
    6054{
     
    6256        assert(hub_fun);
    6357
    64         const usb_address_t hub_address =
     58        int ret;
     59
     60        usb_address_t hub_address =
    6561            device_keeper_get_free_address(&instance->manager, USB_SPEED_FULL);
    6662        if (hub_address <= 0) {
    67                 usb_log_error("Failed(%d) to get OHCI root hub address.\n",
    68                     hub_address);
     63                usb_log_error("Failed to get OHCI root hub address.\n");
    6964                return hub_address;
    7065        }
     
    7368            &instance->manager, hub_address, hub_fun->handle);
    7469
    75 #define CHECK_RET_RELEASE(ret, message...) \
    76 if (ret != EOK) { \
    77         usb_log_error(message); \
    78         hc_remove_endpoint(instance, hub_address, 0, USB_DIRECTION_BOTH); \
    79         usb_device_keeper_release(&instance->manager, hub_address); \
    80         return ret; \
    81 } else (void)0
    82 
    83         int ret = hc_add_endpoint(instance, hub_address, 0, USB_SPEED_FULL,
     70        ret = hc_add_endpoint(instance, hub_address, 0, USB_SPEED_FULL,
    8471            USB_TRANSFER_CONTROL, USB_DIRECTION_BOTH, 64, 0, 0);
    85         CHECK_RET_RELEASE(ret, "Failed(%d) to add OHCI rh endpoint 0.\n", ret);
     72        if (ret != EOK) {
     73                usb_log_error("Failed to add OHCI rh endpoint 0.\n");
     74                usb_device_keeper_release(&instance->manager, hub_address);
     75                return ret;
     76        }
    8677
    8778        char *match_str = NULL;
    8879        /* DDF needs heap allocated string */
    8980        ret = asprintf(&match_str, "usb&class=hub");
    90         ret = ret > 0 ? 0 : ret;
    91         CHECK_RET_RELEASE(ret, "Failed(%d) to create match-id string.\n", ret);
     81        if (ret < 0) {
     82                usb_log_error(
     83                    "Failed(%d) to create root hub match-id string.\n", ret);
     84                usb_device_keeper_release(&instance->manager, hub_address);
     85                return ret;
     86        }
    9287
    9388        ret = ddf_fun_add_match_id(hub_fun, match_str, 100);
    94         CHECK_RET_RELEASE(ret, "Failed(%d) add root hub match-id.\n", ret);
    95 
     89        if (ret != EOK) {
     90                usb_log_error("Failed add root hub match-id.\n");
     91        }
    9692        ret = ddf_fun_bind(hub_fun);
    97         CHECK_RET_RELEASE(ret, "Failed(%d) to bind root hub function.\n", ret);
    98 
    99         return EOK;
    100 #undef CHECK_RET_RELEASE
    101 }
    102 /*----------------------------------------------------------------------------*/
    103 /** Initialize OHCI hc driver structure
    104  *
    105  * @param[in] instance Memory place for the structure.
    106  * @param[in] regs Address of the memory mapped I/O registers.
    107  * @param[in] reg_size Size of the memory mapped area.
    108  * @param[in] interrupts True if w interrupts should be used
    109  * @return Error code
    110  */
     93        return ret;
     94}
     95/*----------------------------------------------------------------------------*/
    11196int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts)
    11297{
     
    136121#undef CHECK_RET_RETURN
    137122
     123
     124//      hc_init_hw(instance);
     125        hc_gain_control(instance);
    138126        fibril_mutex_initialize(&instance->guard);
    139         hc_gain_control(instance);
    140127
    141128        rh_init(&instance->rh, instance->registers);
     
    150137}
    151138/*----------------------------------------------------------------------------*/
    152 /** Create end register endpoint structures
    153  *
    154  * @param[in] instance OHCI driver structure.
    155  * @param[in] address USB address of the device.
    156  * @param[in] endpoint USB endpoint number.
    157  * @param[in] speed Communication speeed of the device.
    158  * @param[in] type Endpoint's transfer type.
    159  * @param[in] direction Endpoint's direction.
    160  * @param[in] mps Maximum packet size the endpoint accepts.
    161  * @param[in] size Maximum allowed buffer size.
    162  * @param[in] interval Time between transfers(interrupt transfers only).
    163  * @return Error code
    164  */
    165139int hc_add_endpoint(
    166140    hc_t *instance, usb_address_t address, usb_endpoint_t endpoint,
     
    220194}
    221195/*----------------------------------------------------------------------------*/
    222 /** Dequeue and delete endpoint structures
    223  *
    224  * @param[in] instance OHCI hc driver structure.
    225  * @param[in] address USB address of the device.
    226  * @param[in] endpoint USB endpoint number.
    227  * @param[in] direction Direction of the endpoint.
    228  * @return Error code
    229  */
    230196int hc_remove_endpoint(hc_t *instance, usb_address_t address,
    231197    usb_endpoint_t endpoint, usb_direction_t direction)
     
    278244}
    279245/*----------------------------------------------------------------------------*/
    280 /** Get access to endpoint structures
    281  *
    282  * @param[in] instance OHCI hc driver structure.
    283  * @param[in] address USB address of the device.
    284  * @param[in] endpoint USB endpoint number.
    285  * @param[in] direction Direction of the endpoint.
    286  * @param[out] bw Reserved bandwidth.
    287  * @return Error code
    288  */
    289246endpoint_t * hc_get_endpoint(hc_t *instance, usb_address_t address,
    290247    usb_endpoint_t endpoint, usb_direction_t direction, size_t *bw)
     
    298255}
    299256/*----------------------------------------------------------------------------*/
    300 /** Add USB transfer to the schedule.
    301  *
    302  * @param[in] instance OHCI hc driver structure.
    303  * @param[in] batch Batch representing the transfer.
    304  * @return Error code.
    305  */
    306257int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch)
    307258{
     
    310261        assert(batch->ep);
    311262
    312         /* Check for root hub communication */
     263        /* check for root hub communication */
    313264        if (batch->ep->address == instance->rh.address) {
    314265                return rh_request(&instance->rh, batch);
     
    318269        list_append(&batch->link, &instance->pending_batches);
    319270        batch_commit(batch);
    320 
    321         /* Control and bulk schedules need a kick to start working */
    322         switch (batch->ep->transfer_type)
    323         {
     271        switch (batch->ep->transfer_type) {
    324272        case USB_TRANSFER_CONTROL:
    325273                instance->registers->command_status |= CS_CLF;
     
    331279                break;
    332280        }
     281
    333282        fibril_mutex_unlock(&instance->guard);
    334283        return EOK;
    335284}
    336285/*----------------------------------------------------------------------------*/
    337 /** Interrupt handling routine
    338  *
    339  * @param[in] instance OHCI hc driver structure.
    340  * @param[in] status Value of the status register at the time of interrupt.
    341  */
    342286void hc_interrupt(hc_t *instance, uint32_t status)
    343287{
     
    348292        if (status & I_RHSC)
    349293                rh_interrupt(&instance->rh);
     294
    350295
    351296        if (status & I_WDH) {
     
    371316                fibril_mutex_unlock(&instance->guard);
    372317        }
    373 
    374         if (status & I_UE) {
    375                 hc_start_hw(instance);
    376         }
    377 
    378 }
    379 /*----------------------------------------------------------------------------*/
    380 /** Check status register regularly
    381  *
    382  * @param[in] instance OHCI hc driver structure.
    383  * @return Error code
    384  */
     318}
     319/*----------------------------------------------------------------------------*/
    385320int interrupt_emulator(hc_t *instance)
    386321{
     
    391326                instance->registers->interrupt_status = status;
    392327                hc_interrupt(instance, status);
    393                 async_usleep(10000);
     328                async_usleep(50000);
    394329        }
    395330        return EOK;
    396331}
    397332/*----------------------------------------------------------------------------*/
    398 /** Turn off any (BIOS)driver that might be in control of the device.
    399  *
    400  * @param[in] instance OHCI hc driver structure.
    401  */
    402333void hc_gain_control(hc_t *instance)
    403334{
     
    449380}
    450381/*----------------------------------------------------------------------------*/
    451 /** OHCI hw initialization routine.
    452  *
    453  * @param[in] instance OHCI hc driver structure.
    454  */
    455382void hc_start_hw(hc_t *instance)
    456383{
     
    520447}
    521448/*----------------------------------------------------------------------------*/
    522 /** Initialize schedule queues
    523  *
    524  * @param[in] instance OHCI hc driver structure
    525  * @return Error code
    526  */
    527449int hc_init_transfer_lists(hc_t *instance)
    528450{
    529451        assert(instance);
     452
    530453#define SETUP_ENDPOINT_LIST(type) \
    531454do { \
     
    535458                usb_log_error("Failed(%d) to setup %s endpoint list.\n", \
    536459                    ret, name); \
    537                 endpoint_list_fini(&instance->lists[USB_TRANSFER_ISOCHRONOUS]);\
     460                endpoint_list_fini(&instance->lists[USB_TRANSFER_ISOCHRONOUS]); \
    538461                endpoint_list_fini(&instance->lists[USB_TRANSFER_INTERRUPT]); \
    539462                endpoint_list_fini(&instance->lists[USB_TRANSFER_CONTROL]); \
    540463                endpoint_list_fini(&instance->lists[USB_TRANSFER_BULK]); \
    541                 return ret; \
    542464        } \
    543465} while (0)
     
    554476}
    555477/*----------------------------------------------------------------------------*/
    556 /** Initialize memory structures used by the OHCI hcd.
    557  *
    558  * @param[in] instance OHCI hc driver structure.
    559  * @return Error code.
    560  */
    561478int hc_init_memory(hc_t *instance)
    562479{
     
    565482        bzero(&instance->rh, sizeof(instance->rh));
    566483        /* Init queues */
    567         const int ret = hc_init_transfer_lists(instance);
    568         if (ret != EOK) {
    569                 return ret;
    570         }
     484        hc_init_transfer_lists(instance);
    571485
    572486        /*Init HCCA */
     
    588502        /* Init interrupt code */
    589503        instance->interrupt_code.cmds = instance->interrupt_commands;
    590         instance->interrupt_code.cmdcount = OHCI_NEEDED_IRQ_COMMANDS;
    591504        {
    592505                /* Read status register */
     
    608521                instance->interrupt_commands[2].srcarg = 2;
    609522
    610                 /* Write-clean status register */
     523                /* Write clean status register */
    611524                instance->interrupt_commands[3].cmd = CMD_MEM_WRITE_A_32;
    612525                instance->interrupt_commands[3].srcarg = 1;
     
    616529                /* Accept interrupt */
    617530                instance->interrupt_commands[4].cmd = CMD_ACCEPT;
     531
     532                instance->interrupt_code.cmdcount = OHCI_NEEDED_IRQ_COMMANDS;
    618533        }
    619534
Note: See TracChangeset for help on using the changeset viewer.