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

Changeset 28d9c95 in mainline


Ignore:
Timestamp:
2011-05-17T12:21:55Z (11 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master
Children:
d736fe38
Parents:
5f94a0c
Message:

Cleanup, add normal and doxygen comments

Location:
uspace/drv
Files:
4 edited

Legend:

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

    r5f94a0c r28d9c95  
    4444#include "hw_struct/transfer_descriptor.h"
    4545
     46/** OHCI specific data required for USB transfer */
    4647typedef struct ohci_transfer_batch {
     48        /** Endpoint descriptor of the target endpoint. */
    4749        ed_t *ed;
     50        /** List of TDs needed for the transfer */
    4851        td_t **tds;
     52        /** Number of TDs used by the transfer */
    4953        size_t td_count;
     54        /** Dummy TD to be left at the ED and used by the next transfer */
    5055        size_t leave_td;
    51         char *device_buffer;
     56        /** Data buffer, must be accessible byb the OHCI hw. */
     57        void *device_buffer;
    5258} ohci_transfer_batch_t;
    53 
     59/*----------------------------------------------------------------------------*/
     60static void batch_control(usb_transfer_batch_t *instance,
     61    usb_direction_t data_dir, usb_direction_t status_dir);
     62static void batch_data(usb_transfer_batch_t *instance);
     63/*----------------------------------------------------------------------------*/
     64/** Safely destructs ohci_transfer_batch_t structure
     65 *
     66 * @param[in] ohci_batch Instance to destroy.
     67 */
    5468static void ohci_transfer_batch_dispose(void *ohci_batch)
    5569{
     
    6983}
    7084/*----------------------------------------------------------------------------*/
    71 static void batch_control(usb_transfer_batch_t *instance,
    72     usb_direction_t data_dir, usb_direction_t status_dir);
    73 static void batch_data(usb_transfer_batch_t *instance);
    74 /*----------------------------------------------------------------------------*/
     85/** Allocate memory initialize internal structures
     86 *
     87 * @param[in] fun DDF function to pass to callback.
     88 * @param[in] ep Communication target
     89 * @param[in] buffer Data source/destination.
     90 * @param[in] buffer_size Size of the buffer.
     91 * @param[in] setup_buffer Setup data source (if not NULL)
     92 * @param[in] setup_size Size of setup_buffer (should be always 8)
     93 * @param[in] func_in function to call on inbound transfer completion
     94 * @param[in] func_out function to call on outbound transfer completion
     95 * @param[in] arg additional parameter to func_in or func_out
     96 * @return Valid pointer if all structures were successfully created,
     97 * NULL otherwise.
     98 *
     99 * Allocates and initializes structures needed by the OHCI hw for the transfer.
     100 */
    75101usb_transfer_batch_t * batch_get(ddf_fun_t *fun, endpoint_t *ep,
    76102    char *buffer, size_t buffer_size, char* setup_buffer, size_t setup_size,
     
    107133        }
    108134
    109         /* we need one extra place for td that is currently assigned to hcd_ep*/
     135        /* We need an extra place for TD that is currently assigned to hcd_ep*/
    110136        data->tds = calloc(sizeof(td_t*), data->td_count + 1);
    111137        CHECK_NULL_DISPOSE_RETURN(data->tds,
    112138            "Failed to allocate transfer descriptors.\n");
    113139
     140        /* Add TD left over by the previous transfer */
    114141        data->tds[0] = hcd_ep->td;
    115142        data->leave_td = 0;
     
    123150        data->ed = hcd_ep->ed;
    124151
     152        /* NOTE: OHCI is capable of handling buffer that crosses page boundaries
     153         * it is, however, not capable of handling buffer that accupies more
     154         * than two pages (the first page is computete using start pointer, the
     155         * other using end pointer)*/
    125156        if (setup_size + buffer_size > 0) {
    126157                data->device_buffer = malloc32(setup_size + buffer_size);
     
    135166}
    136167/*----------------------------------------------------------------------------*/
     168/** Check batch TDs' status.
     169 *
     170 * @param[in] instance Batch structure to use.
     171 * @return False, if there is an active TD, true otherwise.
     172 *
     173 * Walk all TDs (usually there is just one). Stop with false if there is an
     174 * active TD. Stop with true if an error is found. Return true if the walk
     175 * completes with the last TD.
     176 */
    137177bool batch_is_complete(usb_transfer_batch_t *instance)
    138178{
     
    178218        /* Clear possible ED HALT */
    179219        data->ed->td_head &= ~ED_TDHEAD_HALTED_FLAG;
    180         uint32_t pa = addr_to_phys(hcd_ep->td);
     220        const uint32_t pa = addr_to_phys(hcd_ep->td);
    181221        assert(pa == (data->ed->td_head & ED_TDHEAD_PTR_MASK));
    182222        assert(pa == (data->ed->td_tail & ED_TDTAIL_PTR_MASK));
     
    185225}
    186226/*----------------------------------------------------------------------------*/
     227/** Starts execution of the TD list
     228 *
     229 * @param[in] instance Batch structure to use
     230 */
    187231void batch_commit(usb_transfer_batch_t *instance)
    188232{
     
    193237}
    194238/*----------------------------------------------------------------------------*/
     239/** Prepares control write transfer.
     240 *
     241 * @param[in] instance Batch structure to use.
     242 *
     243 * Uses generic control transfer using direction OUT(data stage) and
     244 * IN(status stage).
     245 */
    195246void batch_control_write(usb_transfer_batch_t *instance)
    196247{
     
    203254}
    204255/*----------------------------------------------------------------------------*/
     256/** Prepares control read transfer.
     257 *
     258 * @param[in] instance Batch structure to use.
     259 *
     260 * Uses generic control transfer using direction IN(data stage) and
     261 * OUT(status stage).
     262 */
    205263void batch_control_read(usb_transfer_batch_t *instance)
    206264{
     
    211269}
    212270/*----------------------------------------------------------------------------*/
     271/** Prepare interrupt in transfer.
     272 *
     273 * @param[in] instance Batch structure to use.
     274 *
     275 * Data transfer.
     276 */
    213277void batch_interrupt_in(usb_transfer_batch_t *instance)
    214278{
     
    219283}
    220284/*----------------------------------------------------------------------------*/
     285/** Prepare interrupt out transfer.
     286 *
     287 * @param[in] instance Batch structure to use.
     288 *
     289 * Data transfer.
     290 */
    221291void batch_interrupt_out(usb_transfer_batch_t *instance)
    222292{
     
    229299}
    230300/*----------------------------------------------------------------------------*/
     301/** Prepare bulk in transfer.
     302 *
     303 * @param[in] instance Batch structure to use.
     304 *
     305 * Data transfer.
     306 */
    231307void batch_bulk_in(usb_transfer_batch_t *instance)
    232308{
     
    237313}
    238314/*----------------------------------------------------------------------------*/
     315/** Prepare bulk out transfer.
     316 *
     317 * @param[in] instance Batch structure to use.
     318 *
     319 * Data transfer.
     320 */
    239321void batch_bulk_out(usb_transfer_batch_t *instance)
    240322{
     
    247329}
    248330/*----------------------------------------------------------------------------*/
    249 ed_t * batch_ed(usb_transfer_batch_t *instance)
    250 {
    251         assert(instance);
    252         ohci_transfer_batch_t *data = instance->private_data;
    253         assert(data);
    254         return data->ed;
    255 }
    256 /*----------------------------------------------------------------------------*/
     331/** Prepare generic control transfer
     332 *
     333 * @param[in] instance Batch structure to use.
     334 * @param[in] data_dir Direction to use for data stage.
     335 * @param[in] status_dir Direction to use for status stage.
     336 *
     337 * Setup stage with toggle 0 and direction BOTH(SETUP_PID)
     338 * Data stage with alternating toggle and direction supplied by parameter.
     339 * Status stage with toggle 1 and direction supplied by parameter.
     340 */
    257341void batch_control(usb_transfer_batch_t *instance,
    258342    usb_direction_t data_dir, usb_direction_t status_dir)
     
    303387}
    304388/*----------------------------------------------------------------------------*/
     389/** Prepare generic data transfer
     390 *
     391 * @param[in] instance Batch structure to use.
     392 *
     393 * Direction is supplied by the associated ep and toggle is maintained by the
     394 * OHCI hw in ED.
     395 */
    305396void batch_data(usb_transfer_batch_t *instance)
    306397{
  • uspace/drv/ohci/batch.h

    r5f94a0c r28d9c95  
    4141#include <usb/host/batch.h>
    4242
    43 #include "hw_struct/endpoint_descriptor.h"
    44 
    4543usb_transfer_batch_t * batch_get(
    4644    ddf_fun_t *fun, endpoint_t *ep, char *buffer, size_t size,
     
    6563
    6664void batch_bulk_out(usb_transfer_batch_t *instance);
    67 
    68 ed_t * batch_ed(usb_transfer_batch_t *instance);
    6965#endif
    7066/**
  • uspace/drv/ohci/hw_struct/transfer_descriptor.c

    r5f94a0c r28d9c95  
    4444        assert(instance);
    4545        bzero(instance, sizeof(td_t));
    46         instance-> status = 0
     46        instance->status = 0
    4747            | ((dp[dir] & TD_STATUS_DP_MASK) << TD_STATUS_DP_SHIFT)
    4848            | ((CC_NOACCESS2 & TD_STATUS_CC_MASK) << TD_STATUS_CC_SHIFT);
  • uspace/drv/uhci-hcd/batch.c

    r5f94a0c r28d9c95  
    4545#define DEFAULT_ERROR_COUNT 3
    4646
     47/** UHCI specific data required for USB transfer */
    4748typedef struct uhci_transfer_batch {
     49        /** Queue head
     50         * This QH is used to maintain UHCI schedule structure and the element
     51         * pointer points to the first TD of this batch.
     52         */
    4853        qh_t *qh;
     54        /** List of TDs needed for the transfer */
    4955        td_t *tds;
     56        /** Number of TDs used by the transfer */
     57        size_t td_count;
     58        /** Data buffer, must be accessible by the UHCI hw */
    5059        void *device_buffer;
    51         size_t td_count;
    5260} uhci_transfer_batch_t;
    5361/*----------------------------------------------------------------------------*/
    54 static void uhci_transfer_batch_dispose(void *uhci_batch)
    55 {
    56         uhci_transfer_batch_t *instance = uhci_batch;
    57         assert(instance);
    58         free32(instance->device_buffer);
    59         free(instance);
    60 }
    61 /*----------------------------------------------------------------------------*/
    62 
    6362static void batch_control(usb_transfer_batch_t *instance,
    6463    usb_packet_id data_stage, usb_packet_id status_stage);
    6564static void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid);
    66 
     65/*----------------------------------------------------------------------------*/
     66/** Safely destructs uhci_transfer_batch_t structure
     67 *
     68 * @param[in] uhci_batch Instance to destroy.
     69 */
     70static void uhci_transfer_batch_dispose(void *uhci_batch)
     71{
     72        uhci_transfer_batch_t *instance = uhci_batch;
     73        assert(instance);
     74        free32(instance->device_buffer);
     75        free(instance);
     76}
     77/*----------------------------------------------------------------------------*/
    6778/** Allocate memory and initialize internal data structure.
    6879 *
     
    173184                instance->error = td_status(&data->tds[i]);
    174185                if (instance->error != EOK) {
    175                         usb_log_debug("Batch(%p) found error TD(%zu):%" PRIx32 ".\n",
    176                             instance, i, data->tds[i].status);
     186                        usb_log_debug("Batch(%p) found error TD(%zu):%"
     187                            PRIx32 ".\n", instance, i, data->tds[i].status);
    177188                        td_print_status(&data->tds[i]);
    178189
     
    397408/*----------------------------------------------------------------------------*/
    398409/** Provides access to QH data structure.
     410 *
    399411 * @param[in] instance Batch pointer to use.
    400412 * @return Pointer to the QH used by the batch.
Note: See TracChangeset for help on using the changeset viewer.