Changes in / [98d7550:17fc40c] in mainline


Ignore:
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/ipc/irq.c

    r98d7550 r17fc40c  
    370370        if (AS != irq->driver_as) \
    371371                as_switch(AS, irq->driver_as); \
     372        printf("Copying data from address: %p.\n", va); \
    372373        memcpy_from_uspace(&target, va, (sizeof(target))); \
    373374        if (dstarg) \
    … …  
    380381        if (AS != irq->driver_as) \
    381382                as_switch(AS, irq->driver_as); \
     383        printf("Writing data to address: %p.\n", va); \
    382384        memcpy_to_uspace(va, &val, sizeof(val)); \
    383385} while (0)
    … …  
    455457                        uint32_t val;
    456458                        CMD_MEM_READ(val);
     459                        printf("mem READ value: %x.\n", val);
    457460                        break;
    458461                        }

  • uspace/drv/ohci/batch.c

    r98d7550 r17fc40c  
    100100 */
    101101usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
    102     char *buffer, size_t buffer_size,
    103     const char *setup_buffer, size_t setup_size,
     102    char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
    104103    usbhc_iface_transfer_in_callback_t func_in,
    105104    usbhc_iface_transfer_out_callback_t func_out, void *arg)
    … …  
    121120            ohci_transfer_batch_dispose);
    122121
    123         const hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
     122        hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
    124123        assert(hcd_ep);
    125124
    … …  
    130129        data->td_count =
    131130            ((buffer_size + OHCI_TD_MAX_TRANSFER - 1) / OHCI_TD_MAX_TRANSFER);
    132         /* Control transfer need Setup and Status stage */
    133131        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
    134132                data->td_count += 2;
    … …  
    409407        char *buffer = instance->data_buffer;
    410408        while (remain_size > 0) {
    411                 const size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER
    412                     ? OHCI_TD_MAX_TRANSFER : remain_size;
     409                size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
     410                    OHCI_TD_MAX_TRANSFER : remain_size;
    413411
    414412                td_init(data->tds[td_current], instance->ep->direction,

  • uspace/drv/ohci/batch.h

    r98d7550 r17fc40c  
    4343usb_transfer_batch_t * batch_get(
    4444    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
    45     const char *setup_buffer, size_t setup_size,
     45    char *setup_buffer, size_t setup_size,
    4646    usbhc_iface_transfer_in_callback_t func_in,
    4747    usbhc_iface_transfer_out_callback_t func_out,

  • uspace/drv/ohci/endpoint_list.h

    r98d7550 r17fc40c  
    4242
    4343/** Structure maintains both OHCI queue and software list of active endpoints.*/
    44 typedef struct endpoint_list {
     44typedef struct endpoint_list
     45{
    4546        /** Guard against add/remove races */
    4647        fibril_mutex_t guard;
    … …  
    6869
    6970int endpoint_list_init(endpoint_list_t *instance, const char *name);
     71
    7072void endpoint_list_set_next(endpoint_list_t *instance, endpoint_list_t *next);
     73
    7174void endpoint_list_add_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
     75
    7276void endpoint_list_remove_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
    7377#endif

  • uspace/drv/ohci/hc.c

    r98d7550 r17fc40c  
    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{
    … …  
    378322}
    379323/*----------------------------------------------------------------------------*/
    380 /** Check status register regularly
    381  *
    382  * @param[in] instance OHCI hc driver structure.
    383  * @return Error code
    384  */
    385324int interrupt_emulator(hc_t *instance)
    386325{
    … …  
    391330                instance->registers->interrupt_status = status;
    392331                hc_interrupt(instance, status);
    393                 async_usleep(10000);
     332                async_usleep(50000);
    394333        }
    395334        return EOK;
    396335}
    397336/*----------------------------------------------------------------------------*/
    398 /** Turn off any (BIOS)driver that might be in control of the device.
    399  *
    400  * @param[in] instance OHCI hc driver structure.
    401  */
    402337void hc_gain_control(hc_t *instance)
    403338{
    … …  
    449384}
    450385/*----------------------------------------------------------------------------*/
    451 /** OHCI hw initialization routine.
    452  *
    453  * @param[in] instance OHCI hc driver structure.
    454  */
    455386void hc_start_hw(hc_t *instance)
    456387{
    … …  
    520451}
    521452/*----------------------------------------------------------------------------*/
    522 /** Initialize schedule queues
    523  *
    524  * @param[in] instance OHCI hc driver structure
    525  * @return Error code
    526  */
    527453int hc_init_transfer_lists(hc_t *instance)
    528454{
    … …  
    540466                endpoint_list_fini(&instance->lists[USB_TRANSFER_BULK]); \
    541467        } \
    542         return ret; \
    543468} while (0)
    544469
    … …  
    554479}
    555480/*----------------------------------------------------------------------------*/
    556 /** Initialize memory structures used by the OHCI hcd.
    557  *
    558  * @param[in] instance OHCI hc driver structure.
    559  * @return Error code.
    560  */
    561481int hc_init_memory(hc_t *instance)
    562482{
    … …  
    585505        /* Init interrupt code */
    586506        instance->interrupt_code.cmds = instance->interrupt_commands;
    587         instance->interrupt_code.cmdcount = OHCI_NEEDED_IRQ_COMMANDS;
    588507        {
    589508                /* Read status register */
    … …  
    605524                instance->interrupt_commands[2].srcarg = 2;
    606525
    607                 /* Write-clean status register */
     526                /* Write clean status register */
    608527                instance->interrupt_commands[3].cmd = CMD_MEM_WRITE_A_32;
    609528                instance->interrupt_commands[3].srcarg = 1;
    … …  
    613532                /* Accept interrupt */
    614533                instance->interrupt_commands[4].cmd = CMD_ACCEPT;
     534
     535                instance->interrupt_code.cmdcount = OHCI_NEEDED_IRQ_COMMANDS;
    615536        }
    616537

  • uspace/drv/ohci/hc.h

    r98d7550 r17fc40c  
    5353#define OHCI_NEEDED_IRQ_COMMANDS 5
    5454
    55 /** Main OHCI drier structure */
    5655typedef struct hc {
    57         /** USB bus driver, devices and addresses */
    58         usb_device_keeper_t manager;
    59         /** USB bus driver, endpoints */
    60         usb_endpoint_manager_t ep_manager;
    61 
    62         /** Memory mapped I/O registers area */
    6356        ohci_regs_t *registers;
    64         /** Host controller communication area structure */
    6557        hcca_t *hcca;
    6658
    67         /** Transfer schedules */
     59        usb_address_t rh_address;
     60        rh_t rh;
     61
    6862        endpoint_list_t lists[4];
    69         /** List of active transfers */
    7063        link_t pending_batches;
    7164
    72         /** Fibril for periodic checks if interrupts can't be used */
     65        usb_device_keeper_t manager;
     66        usb_endpoint_manager_t ep_manager;
    7367        fid_t interrupt_emulator;
    74 
    75         /** Guards schedule and endpoint manipulation */
    7668        fibril_mutex_t guard;
    7769
    … …  
    8173        /** Commands that form interrupt code */
    8274        irq_cmd_t interrupt_commands[OHCI_NEEDED_IRQ_COMMANDS];
    83 
    84         /** USB hub emulation structure */
    85         rh_t rh;
    8675} hc_t;
    8776
    8877int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
     78
    8979int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts);
     80
    9081void hc_start_hw(hc_t *instance);
    9182
    … …  
    9485 * @param[in] instance Host controller structure to use.
    9586 */
    96 static inline void hc_fini(hc_t *instance)
    97         { /* TODO: implement*/ };
     87static inline void hc_fini(hc_t *instance) { /* TODO: implement*/ };
    9888
    9989int hc_add_endpoint(hc_t *instance, usb_address_t address, usb_endpoint_t ep,
    10090    usb_speed_t speed, usb_transfer_type_t type, usb_direction_t direction,
    10191    size_t max_packet_size, size_t size, unsigned interval);
     92
    10293int hc_remove_endpoint(hc_t *instance, usb_address_t address,
    10394    usb_endpoint_t endpoint, usb_direction_t direction);
     95
    10496endpoint_t * hc_get_endpoint(hc_t *instance, usb_address_t address,
    10597    usb_endpoint_t endpoint, usb_direction_t direction, size_t *bw);
    10698
    10799int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch);
     100
    108101void hc_interrupt(hc_t *instance, uint32_t status);
    109102
    … …  
    114107 */
    115108static inline hc_t * fun_to_hc(ddf_fun_t *fun)
    116         { return fun->driver_data; }
     109        { return (hc_t*)fun->driver_data; }
    117110#endif
    118111/**

  • uspace/drv/ohci/hcd_endpoint.c

    r98d7550 r17fc40c  
    3535#include "hcd_endpoint.h"
    3636
    37 /** Callback to set toggle on ED.
    38  *
    39  * @param[in] hcd_ep hcd endpoint structure
    40  * @param[in] toggle new value of toggle bit
    41  */
    4237static void hcd_ep_toggle_set(void *hcd_ep, int toggle)
    4338{
    … …  
    4742        ed_toggle_set(instance->ed, toggle);
    4843}
    49 /*----------------------------------------------------------------------------*/
    50 /** Callback to get value of toggle bit.
    51  *
    52  * @param[in] hcd_ep hcd endpoint structure
    53  * @return Current value of toggle bit.
    54  */
    5544static int hcd_ep_toggle_get(void *hcd_ep)
    5645{
    … …  
    6049        return ed_toggle_get(instance->ed);
    6150}
    62 /*----------------------------------------------------------------------------*/
    63 /** Creates new hcd endpoint representation.
    64  *
    65  * @param[in] ep USBD endpoint structure
    66  * @return pointer to a new hcd endpoint structure, NULL on failure.
    67  */
     51
     52
    6853hcd_endpoint_t * hcd_endpoint_assign(endpoint_t *ep)
    6954{
    … …  
    9378}
    9479/*----------------------------------------------------------------------------*/
    95 /** Disposes assigned hcd endpoint structure
    96  *
    97  * @param[in] ep USBD endpoint structure
    98  */
     80hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep)
     81{
     82        assert(ep);
     83        return ep->hc_data.data;
     84}
     85/*----------------------------------------------------------------------------*/
    9986void hcd_endpoint_clear(endpoint_t *ep)
    10087{

  • uspace/drv/ohci/hcd_endpoint.h

    r98d7550 r17fc40c  
    4242#include "hw_struct/transfer_descriptor.h"
    4343
    44 /** Connector structure linking ED to to prepared TD. */
    45 typedef struct hcd_endpoint {
    46         /** OHCI endpoint descriptor */
     44typedef struct hcd_endpoint
     45{
    4746        ed_t *ed;
    48         /** Currently enqueued transfer descriptor */
    4947        td_t *td;
    50         /** Linked list used by driver software */
    5148        link_t link;
    5249} hcd_endpoint_t;
    5350
    5451hcd_endpoint_t * hcd_endpoint_assign(endpoint_t *ep);
     52
     53hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep);
     54
    5555void hcd_endpoint_clear(endpoint_t *ep);
    56 
    57 /** Get and convert assigned hcd_endpoint_t structure
    58  * @param[in] ep USBD endpoint structure.
    59  * @return Pointer to assigned hcd endpoint structure
    60  */
    61 static inline hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep)
    62 {
    63         assert(ep);
    64         return ep->hc_data.data;
    65 }
    66 
    6756#endif
    6857/**

  • uspace/drv/ohci/ohci_regs.h

    r98d7550 r17fc40c  
    3636#include <stdint.h>
    3737
    38 /** OHCI memory mapped registers structure */
    39 typedef struct ohci_regs {
     38typedef struct ohci_regs
     39{
    4040        const volatile uint32_t revision;
    4141        volatile uint32_t control;

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

    r98d7550 r17fc40c  
    9595 */
    9696usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
    97     char *buffer, size_t buffer_size,
    98     const char* setup_buffer, size_t setup_size,
     97    char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
    9998    usbhc_iface_transfer_in_callback_t func_in,
    10099    usbhc_iface_transfer_out_callback_t func_out, void *arg)

  • uspace/drv/uhci-hcd/batch.h

    r98d7550 r17fc40c  
    4545usb_transfer_batch_t * batch_get(
    4646    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
    47     const char *setup_buffer, size_t setup_size,
     47    char *setup_buffer, size_t setup_size,
    4848    usbhc_iface_transfer_in_callback_t func_in,
    4949    usbhc_iface_transfer_out_callback_t func_out,
    … …  
    5555
    5656void batch_control_write(usb_transfer_batch_t *instance);
     57
    5758void batch_control_read(usb_transfer_batch_t *instance);
    5859
    5960void batch_interrupt_in(usb_transfer_batch_t *instance);
     61
    6062void batch_interrupt_out(usb_transfer_batch_t *instance);
    6163
    6264void batch_bulk_in(usb_transfer_batch_t *instance);
     65
    6366void batch_bulk_out(usb_transfer_batch_t *instance);
    6467

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

    r98d7550 r17fc40c  
    5757static int hc_debug_checker(void *arg);
    5858/*----------------------------------------------------------------------------*/
    59 /** Initialize UHCI hc driver structure
     59/** Initialize UHCI hcd driver structure
    6060 *
    6161 * @param[in] instance Memory place to initialize.

  • uspace/drv/uhci-hcd/hc.h

    r98d7550 r17fc40c  
    9595#define UHCI_NEEDED_IRQ_COMMANDS 5
    9696
    97 /** Main UHCI driver structure */
     97/* Main HC driver structure */
    9898typedef struct hc {
    9999        /** USB bus driver, devices and addresses */

  • uspace/drv/uhci-hcd/transfer_list.h

    r98d7550 r17fc40c  
    4343 * of currently executed transfers
    4444 */
    45 typedef struct transfer_list {
     45typedef struct transfer_list
     46{
    4647        /** Guard against multiple add/remove races */
    4748        fibril_mutex_t guard;
Note: See TracChangeset for help on using the changeset viewer.