Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 02cacce in mainline


Ignore:
Timestamp:
2011-05-18T18:24:22Z (11 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master
Children:
030937e
Parents:
45e0e07
Message:

Doxygen and some minor code-style changes

Location:
uspace/drv
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/ohci/batch.c

    r45e0e07 r02cacce  
    100100 */
    101101usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
    102     char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
     102    char *buffer, size_t buffer_size,
     103    const char *setup_buffer, size_t setup_size,
    103104    usbhc_iface_transfer_in_callback_t func_in,
    104105    usbhc_iface_transfer_out_callback_t func_out, void *arg)
     
    120121            ohci_transfer_batch_dispose);
    121122
    122         hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
     123        const hcd_endpoint_t *hcd_ep = hcd_endpoint_get(ep);
    123124        assert(hcd_ep);
    124125
     
    129130        data->td_count =
    130131            ((buffer_size + OHCI_TD_MAX_TRANSFER - 1) / OHCI_TD_MAX_TRANSFER);
     132        /* Control transfer need Setup and Status stage */
    131133        if (ep->transfer_type == USB_TRANSFER_CONTROL) {
    132134                data->td_count += 2;
     
    407409        char *buffer = instance->data_buffer;
    408410        while (remain_size > 0) {
    409                 size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
    410                     OHCI_TD_MAX_TRANSFER : remain_size;
     411                const size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER
     412                    ? OHCI_TD_MAX_TRANSFER : remain_size;
    411413
    412414                td_init(data->tds[td_current], instance->ep->direction,
  • uspace/drv/ohci/batch.h

    r45e0e07 r02cacce  
    4343usb_transfer_batch_t * batch_get(
    4444    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
    45     char *setup_buffer, size_t setup_size,
     45    const 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

    r45e0e07 r02cacce  
    4242
    4343/** Structure maintains both OHCI queue and software list of active endpoints.*/
    44 typedef struct endpoint_list
    45 {
     44typedef struct endpoint_list {
    4645        /** Guard against add/remove races */
    4746        fibril_mutex_t guard;
     
    6968
    7069int endpoint_list_init(endpoint_list_t *instance, const char *name);
    71 
    7270void endpoint_list_set_next(endpoint_list_t *instance, endpoint_list_t *next);
    73 
    7471void endpoint_list_add_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
    75 
    7672void endpoint_list_remove_ep(endpoint_list_t *instance, hcd_endpoint_t *hcd_ep);
    7773#endif
  • uspace/drv/ohci/hc.c

    r45e0e07 r02cacce  
    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 */
    5359int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun)
    5460{
     
    95101}
    96102/*----------------------------------------------------------------------------*/
     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 */
    97111int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts)
    98112{
     
    136150}
    137151/*----------------------------------------------------------------------------*/
     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 */
    138165int hc_add_endpoint(
    139166    hc_t *instance, usb_address_t address, usb_endpoint_t endpoint,
     
    193220}
    194221/*----------------------------------------------------------------------------*/
     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 */
    195230int hc_remove_endpoint(hc_t *instance, usb_address_t address,
    196231    usb_endpoint_t endpoint, usb_direction_t direction)
     
    243278}
    244279/*----------------------------------------------------------------------------*/
     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 */
    245289endpoint_t * hc_get_endpoint(hc_t *instance, usb_address_t address,
    246290    usb_endpoint_t endpoint, usb_direction_t direction, size_t *bw)
     
    254298}
    255299/*----------------------------------------------------------------------------*/
     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 */
    256306int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch)
    257307{
     
    260310        assert(batch->ep);
    261311
    262         /* check for root hub communication */
     312        /* Check for root hub communication */
    263313        if (batch->ep->address == instance->rh.address) {
    264314                return rh_request(&instance->rh, batch);
     
    268318        list_append(&batch->link, &instance->pending_batches);
    269319        batch_commit(batch);
    270         switch (batch->ep->transfer_type) {
     320
     321        /* Control and bulk schedules need a kick to start working */
     322        switch (batch->ep->transfer_type)
     323        {
    271324        case USB_TRANSFER_CONTROL:
    272325                instance->registers->command_status |= CS_CLF;
     
    278331                break;
    279332        }
    280 
    281333        fibril_mutex_unlock(&instance->guard);
    282334        return EOK;
    283335}
    284336/*----------------------------------------------------------------------------*/
     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 */
    285342void hc_interrupt(hc_t *instance, uint32_t status)
    286343{
     
    321378}
    322379/*----------------------------------------------------------------------------*/
     380/** Check status register regularly
     381 *
     382 * @param[in] instance OHCI hc driver structure.
     383 * @return Error code
     384 */
    323385int interrupt_emulator(hc_t *instance)
    324386{
     
    329391                instance->registers->interrupt_status = status;
    330392                hc_interrupt(instance, status);
    331                 async_usleep(50000);
     393                async_usleep(10000);
    332394        }
    333395        return EOK;
    334396}
    335397/*----------------------------------------------------------------------------*/
     398/** Turn off any (BIOS)driver that might be in control of the device.
     399 *
     400 * @param[in] instance OHCI hc driver structure.
     401 */
    336402void hc_gain_control(hc_t *instance)
    337403{
     
    383449}
    384450/*----------------------------------------------------------------------------*/
     451/** OHCI hw initialization routine.
     452 *
     453 * @param[in] instance OHCI hc driver structure.
     454 */
    385455void hc_start_hw(hc_t *instance)
    386456{
     
    450520}
    451521/*----------------------------------------------------------------------------*/
     522/** Initialize schedule queues
     523 *
     524 * @param[in] instance OHCI hc driver structure
     525 * @return Error code
     526 */
    452527int hc_init_transfer_lists(hc_t *instance)
    453528{
     
    465540                endpoint_list_fini(&instance->lists[USB_TRANSFER_BULK]); \
    466541        } \
     542        return ret; \
    467543} while (0)
    468544
     
    478554}
    479555/*----------------------------------------------------------------------------*/
     556/** Initialize memory structures used by the OHCI hcd.
     557 *
     558 * @param[in] instance OHCI hc driver structure.
     559 * @return Error code.
     560 */
    480561int hc_init_memory(hc_t *instance)
    481562{
     
    504585        /* Init interrupt code */
    505586        instance->interrupt_code.cmds = instance->interrupt_commands;
     587        instance->interrupt_code.cmdcount = OHCI_NEEDED_IRQ_COMMANDS;
    506588        {
    507589                /* Read status register */
     
    523605                instance->interrupt_commands[2].srcarg = 2;
    524606
    525                 /* Write clean status register */
     607                /* Write-clean status register */
    526608                instance->interrupt_commands[3].cmd = CMD_MEM_WRITE_A_32;
    527609                instance->interrupt_commands[3].srcarg = 1;
     
    531613                /* Accept interrupt */
    532614                instance->interrupt_commands[4].cmd = CMD_ACCEPT;
    533 
    534                 instance->interrupt_code.cmdcount = OHCI_NEEDED_IRQ_COMMANDS;
    535615        }
    536616
  • uspace/drv/ohci/hc.h

    r45e0e07 r02cacce  
    5353#define OHCI_NEEDED_IRQ_COMMANDS 5
    5454
     55/** Main OHCI drier structure */
    5556typedef 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 */
    5663        ohci_regs_t *registers;
     64        /** Host controller communication area structure */
    5765        hcca_t *hcca;
    5866
    59         usb_address_t rh_address;
    60         rh_t rh;
    61 
     67        /** Transfer schedules */
    6268        endpoint_list_t lists[4];
     69        /** List of active transfers */
    6370        link_t pending_batches;
    6471
    65         usb_device_keeper_t manager;
    66         usb_endpoint_manager_t ep_manager;
     72        /** Fibril for periodic checks if interrupts can't be used */
    6773        fid_t interrupt_emulator;
     74
     75        /** Guards schedule and endpoint manipulation */
    6876        fibril_mutex_t guard;
    6977
     
    7381        /** Commands that form interrupt code */
    7482        irq_cmd_t interrupt_commands[OHCI_NEEDED_IRQ_COMMANDS];
     83
     84        /** USB hub emulation structure */
     85        rh_t rh;
    7586} hc_t;
    7687
    7788int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
    78 
    7989int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts);
    80 
    8190void hc_start_hw(hc_t *instance);
    8291
     
    8594 * @param[in] instance Host controller structure to use.
    8695 */
    87 static inline void hc_fini(hc_t *instance) { /* TODO: implement*/ };
     96static inline void hc_fini(hc_t *instance)
     97        { /* TODO: implement*/ };
    8898
    8999int hc_add_endpoint(hc_t *instance, usb_address_t address, usb_endpoint_t ep,
    90100    usb_speed_t speed, usb_transfer_type_t type, usb_direction_t direction,
    91101    size_t max_packet_size, size_t size, unsigned interval);
    92 
    93102int hc_remove_endpoint(hc_t *instance, usb_address_t address,
    94103    usb_endpoint_t endpoint, usb_direction_t direction);
    95 
    96104endpoint_t * hc_get_endpoint(hc_t *instance, usb_address_t address,
    97105    usb_endpoint_t endpoint, usb_direction_t direction, size_t *bw);
    98106
    99107int hc_schedule(hc_t *instance, usb_transfer_batch_t *batch);
    100 
    101108void hc_interrupt(hc_t *instance, uint32_t status);
    102109
     
    107114 */
    108115static inline hc_t * fun_to_hc(ddf_fun_t *fun)
    109         { return (hc_t*)fun->driver_data; }
     116        { return fun->driver_data; }
    110117#endif
    111118/**
  • uspace/drv/ohci/hcd_endpoint.c

    r45e0e07 r02cacce  
    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 */
    3742static void hcd_ep_toggle_set(void *hcd_ep, int toggle)
    3843{
     
    4247        ed_toggle_set(instance->ed, toggle);
    4348}
     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 */
    4455static int hcd_ep_toggle_get(void *hcd_ep)
    4556{
     
    4960        return ed_toggle_get(instance->ed);
    5061}
    51 
    52 
     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 */
    5368hcd_endpoint_t * hcd_endpoint_assign(endpoint_t *ep)
    5469{
     
    7893}
    7994/*----------------------------------------------------------------------------*/
    80 hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep)
    81 {
    82         assert(ep);
    83         return ep->hc_data.data;
    84 }
    85 /*----------------------------------------------------------------------------*/
     95/** Disposes assigned hcd endpoint structure
     96 *
     97 * @param[in] ep USBD endpoint structure
     98 */
    8699void hcd_endpoint_clear(endpoint_t *ep)
    87100{
  • uspace/drv/ohci/hcd_endpoint.h

    r45e0e07 r02cacce  
    4242#include "hw_struct/transfer_descriptor.h"
    4343
    44 typedef struct hcd_endpoint
    45 {
     44/** Connector structure linking ED to to prepared TD. */
     45typedef struct hcd_endpoint {
     46        /** OHCI endpoint descriptor */
    4647        ed_t *ed;
     48        /** Currently enqueued transfer descriptor */
    4749        td_t *td;
     50        /** Linked list used by driver software */
    4851        link_t link;
    4952} hcd_endpoint_t;
    5053
    5154hcd_endpoint_t * hcd_endpoint_assign(endpoint_t *ep);
     55void hcd_endpoint_clear(endpoint_t *ep);
    5256
    53 hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep);
     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 */
     61static inline hcd_endpoint_t * hcd_endpoint_get(endpoint_t *ep)
     62{
     63        assert(ep);
     64        return ep->hc_data.data;
     65}
    5466
    55 void hcd_endpoint_clear(endpoint_t *ep);
    5667#endif
    5768/**
  • uspace/drv/ohci/ohci_regs.h

    r45e0e07 r02cacce  
    3636#include <stdint.h>
    3737
    38 typedef struct ohci_regs
    39 {
     38/** OHCI memory mapped registers structure */
     39typedef struct ohci_regs {
    4040        const volatile uint32_t revision;
    4141        volatile uint32_t control;
  • uspace/drv/uhci-hcd/batch.c

    r45e0e07 r02cacce  
    9595 */
    9696usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
    97     char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
     97    char *buffer, size_t buffer_size,
     98    const char* setup_buffer, size_t setup_size,
    9899    usbhc_iface_transfer_in_callback_t func_in,
    99100    usbhc_iface_transfer_out_callback_t func_out, void *arg)
  • uspace/drv/uhci-hcd/batch.h

    r45e0e07 r02cacce  
    4545usb_transfer_batch_t * batch_get(
    4646    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
    47     char *setup_buffer, size_t setup_size,
     47    const 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 
    5857void batch_control_read(usb_transfer_batch_t *instance);
    5958
    6059void batch_interrupt_in(usb_transfer_batch_t *instance);
    61 
    6260void batch_interrupt_out(usb_transfer_batch_t *instance);
    6361
    6462void batch_bulk_in(usb_transfer_batch_t *instance);
    65 
    6663void batch_bulk_out(usb_transfer_batch_t *instance);
    6764
  • uspace/drv/uhci-hcd/hc.c

    r45e0e07 r02cacce  
    5757static int hc_debug_checker(void *arg);
    5858/*----------------------------------------------------------------------------*/
    59 /** Initialize UHCI hcd driver structure
     59/** Initialize UHCI hc driver structure
    6060 *
    6161 * @param[in] instance Memory place to initialize.
  • uspace/drv/uhci-hcd/hc.h

    r45e0e07 r02cacce  
    9595#define UHCI_NEEDED_IRQ_COMMANDS 5
    9696
    97 /* Main HC driver structure */
     97/** Main UHCI driver structure */
    9898typedef struct hc {
    9999        /** USB bus driver, devices and addresses */
  • uspace/drv/uhci-hcd/transfer_list.h

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