htc_internal.h

Linux下SDIO设备的驱动程序

/*
 * Copyright (c) 2004-2005 Atheros Communications Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software withough specific prior written permission
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * HTC internal specific declarations and prototypes
 */

#ifndef _HTC_INTERNAL_H_
#define _HTC_INTERNAL_H_

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/* Header files */
#include "../include/athdefs.h"
#include "../include/athtypes.h"
#include "../include/hw/mbox_host_reg.h"
#include "../include/hw/rtc_reg.h"
#include "../include/htc.h"
#include "../include/AR6000_bmi.h"
#include "../include/osapi.h"
#include "../include/hif.h"

/* HTC operational parameters */
#define HTC_GLOBAL_EVENT_NUM_MAX           2 /* Target available/unavailable */
#define HTC_ENDPOINT_EVENT_NUM_MAX         5 /* Endpoint specific */
#define HTC_REG_REQUEST_LIST_SIZE          16
#define HTC_MESSAGE_SIZE_MAX               1536 - HTC_HEADER_LEN /* Default maximum message size for each mailbox */
#define HTC_TX_CREDITS_NUM_MAX             64
#define HTC_TARGET_RESPONSE_TIMEOUT        2000 /* in ms */

/* Useful macros */
#define GET_ENDPOINT_ID(endPoint) (endPoint - endPoint->target->endPoint)

/* ------- Debug related stuff ------- */
enum {
    ATH_DEBUG_SEND = 0x0001,
    ATH_DEBUG_RECV = 0x0002,
    ATH_DEBUG_SYNC = 0x0004,
    ATH_DEBUG_DUMP = 0x0008,
    ATH_DEBUG_INF  = 0x0010,
    ATH_DEBUG_TRC  = 0x0020,
    ATH_DEBUG_WARN = 0x0040,
    ATH_DEBUG_ERR  = 0x0080,
    ATH_DEBUG_ANY  = 0xFFFF,
};

#ifdef DEBUG
#define AR_DEBUG_PRINTBUF(buffer, length) do {   \
    if (debughtc & ATH_DEBUG_DUMP) {             \
        dumpBytes(buffer, length);               \
    }                                            \
} while(0)
#define PRINTX_ARG(arg...) arg
#define AR_DEBUG_PRINTF(flags, args) do {        \
    if (debughtc & (flags)) {                    \
        A_PRINTF(KERN_ALERT PRINTX_ARG args);      \
    }                                            \
} while (0)
#define AR_DEBUG_ASSERT(test) do {               \
    if (!(test)) {                               \
        AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Debug Assert Caught, File %s, Line: %d, Test:%s \n",__FILE__, __LINE__,#test));         \
    }                                            \
} while(0)
#else
#define AR_DEBUG_PRINTF(flags, args)
#define AR_DEBUG_PRINTBUF(buffer, length)
#define AR_DEBUG_ASSERT(test)
#endif

/* ------- Event Related Data Structures ------- */
typedef struct htc_event_map HTC_EVENT_MAP;
typedef struct event_table_element EVENT_TABLE_ELEMENT;
typedef struct htc_endpoint_event_table HTC_ENDPOINT_EVENT_TABLE;
typedef struct htc_global_event_table HTC_GLOBAL_EVENT_TABLE;

#define FRAME_EVENT(_eventInfo, _buffer, _bufferLength,   \
                    _actualLength, _status, _cookie) do { \
    _eventInfo.buffer  = _buffer;                         \
    _eventInfo.bufferLength = _bufferLength;              \
    _eventInfo.actualLength = _actualLength;              \
    _eventInfo.status = _status;                          \
    _eventInfo.cookie = _cookie;                          \
} while (0)

struct event_table_element {
    HTC_EVENT_ID         id;
    HTC_EVENT_HANDLER    handler;
    void                *param;
};

struct htc_endpoint_event_table {
    EVENT_TABLE_ELEMENT element[HTC_ENDPOINT_EVENT_NUM_MAX];
};

struct htc_global_event_table {
    EVENT_TABLE_ELEMENT element[HTC_GLOBAL_EVENT_NUM_MAX];

};

/* ------ Mailbox Related Data Structures ------ */
typedef struct htc_queue_element HTC_QUEUE_ELEMENT, HTC_REG_REQUEST_ELEMENT, HTC_DATA_REQUEST_ELEMENT;
typedef struct htc_mbox_buffer HTC_MBOX_BUFFER;
typedef struct htc_reg_buffer HTC_REG_BUFFER;
typedef struct htc_data_request_queue HTC_DATA_REQUEST_QUEUE;
typedef struct htc_reg_request_list HTC_REG_REQUEST_LIST;
typedef struct htc_endpoint HTC_ENDPOINT;

typedef enum {
    INT_STATUS_REG,
    ERROR_INT_STATUS_REG,
    CPU_INT_STATUS_REG,
    RX_LOOKAHEAD_VALID_REG,
    RX_LOOKAHEAD0_REG,
    RX_LOOKAHEAD1_REG,
    RX_LOOKAHEAD2_REG,
    RX_LOOKAHEAD3_REG,
    TX_CREDIT_COUNTER_REG,
    TX_CREDIT_COUNTER_RESET_REG,
    TX_CREDIT_COUNTER_DECREMENT_REG,
    SCRATCH_REG,
    INT_STATUS_ENABLE_REG,
    CPU_INT_STATUS_ENABLE_REG,
    ERROR_STATUS_ENABLE_REG,
    COUNTER_INT_STATUS_READ_REG,
    COUNTER_INT_STATUS_ENABLE_REG,
    COUNTER_INT_STATUS_DISABLE_REG,
    INT_WLAN_REG,
    WINDOW_DATA_REG,
    WINDOW_WRITE_ADDR_REG,
    WINDOW_READ_ADDR_REG
} TARGET_REGISTERS;

#define SET_TX_CREDITS_AVAILABLE(endPoint, credits) \
                                    endPoint->txCreditsAvailable[0] = (credits)
#define SET_TX_CREDITS_CONSUMED(endPoint, credits) \
                                    endPoint->txCreditsConsumed = (credits)
#define GET_TX_CREDITS_AVAILABLE(endPoint) \
                                    endPoint->txCreditsAvailable[0]
#define GET_TX_CREDITS_CONSUMED(endPoint) \
                                    endPoint->txCreditsConsumed

#define IS_ELEMENT_FREE(element)	element->buffer.free
#define GET_MBOX_BUFFER(element)	&((element)->buffer.u.mboxBuffer)
#define GET_REG_BUFFER(element)		&((element)->buffer.u.regBuffer)
#define GET_QUEUE_TAIL(queue)		&queue->element[(queue->head + queue->size) % HTC_DATA_REQUEST_RING_BUFFER_SIZE]
#define GET_QUEUE_HEAD(queue)		&queue->element[queue->head]
#define IS_DATA_QUEUE_EMPTY(queue)      (!queue->size)
#define IS_DATA_QUEUE_FULL(queue)       (!(HTC_DATA_REQUEST_RING_BUFFER_SIZE - queue->size))

#define RECYCLE_DATA_REQUEST_ELEMENT(element) do { \
    FILL_MBOX_BUFFER(element, NULL, 0, 0, NULL); \
    (element)->buffer.free = TRUE; \
} while (0)

#define FILL_MBOX_BUFFER(element, _buffer, _bufferLength, _actualLength, _cookie) do { \
    (GET_MBOX_BUFFER(element))->buffer = _buffer; \
    (GET_MBOX_BUFFER(element))->bufferLength = _bufferLength; \
    (GET_MBOX_BUFFER(element))->actualLength = _actualLength; \
    (GET_MBOX_BUFFER(element))->cookie = _cookie; \
} while (0)

#define FILL_REG_BUFFER(element, _buffer, _length, _base, _offset) do { \
    (GET_REG_BUFFER(element))->buffer = _buffer; \
    (GET_REG_BUFFER(element))->length = _length; \
    (GET_REG_BUFFER(element))->base = _base; \
    (GET_REG_BUFFER(element))->offset = _offset; \
} while (0)

struct htc_queue_element {
    A_STATUS	(*completionCB)(HTC_QUEUE_ELEMENT *element, A_STATUS status);
    struct htc_buffer {
        /* In use or available */
        A_BOOL	free;
        union {
            struct htc_mbox_buffer {
                /*
                 * Given by the caller and is associated with the buffer being
                 * queued up.
                 */
                void			*cookie;

                /*
                 * Pointer to the start of the buffer. In the transmit
                 * direction this points to the start of the payload. In the
                 * receive direction, however, the buffer when queued up
                 * points to the start of the HTC header but when returned
                 * to the caller points to the start of the payload
                 */
                A_UCHAR			*buffer;

                /* Holds the length of the buffer */
                A_UINT32		bufferLength;

                /* Holds the length of the payload */
                A_UINT32		actualLength;

                HTC_ENDPOINT    *endPoint;
            } mboxBuffer;
            struct htc_reg_buffer {
                HTC_TARGET		*target;
                A_UCHAR			*buffer;
                A_UINT32		length;
                TARGET_REGISTERS	base;
                A_UINT32		offset;
            } regBuffer;
        } u;
    } buffer;
};

/* This is a FIFO queue of the pending data read/write requests. When a request
has to be issued, the element at the head of the queue is dequeued and
processed. New requests are added at the tail of the queue. The queue can only
support a fixed number of requests and stops adding new requests once the total
number of requests that are pending to be processed and the ones that are still
under process reach the queue capacity */
struct htc_data_request_queue {
    A_UINT32                  head;
    A_UINT32                  size;
    HTC_DATA_REQUEST_ELEMENT  element[HTC_DATA_REQUEST_RING_BUFFER_SIZE];
};

/* This is a list of 'free' register read/write requests. When a request has to
be issued an element is taken from this list and after the completion of the
request is added back to the list */
struct htc_reg_request_list {
    HTC_REG_REQUEST_ELEMENT  element[HTC_REG_REQUEST_LIST_SIZE];
};

struct htc_endpoint {
    /* Enabled or Disabled */
    A_BOOL                   enabled;

    /*
     * Used to hold the length of the frame received from the target in
     * case there are no buffers that have been queued up to receive the
     * data.
     */
    A_UINT32                 rxLengthPending;

    /* Number of frames for which the target has space for at any time */
    A_UINT8                  txCreditsAvailable[1 + HTC_TX_CREDITS_NUM_MAX];

    /*
     * Number of frames that have been sent since the transmit credits
     * were last updated.
     */
    A_UINT8                  txCreditsConsumed;

    A_BOOL                   txCreditsIntrEnable;

    /* Pending Send Queue */
    HTC_DATA_REQUEST_QUEUE   sendQueue;

    /* Pending Receive Queue */
    HTC_DATA_REQUEST_QUEUE   recvQueue;

    /* Inverse reference to the target */
    HTC_TARGET              *target;

    /* Block size configured for the endpoint */
    A_UINT32                 blockSize;

    /* Event Table */
    HTC_ENDPOINT_EVENT_TABLE eventTable;

    /* Stating address of the endpoint */
    A_UINT32                 address;
};

/* ------- Target Related Data structures ------- */
typedef struct htc_register_table HTC_REGISTER_TABLE;

/*
 * The following Register table only contain those registers that are used
 * in HTC. It does not reflect the actual register layout in the hardware
 */
struct htc_register_table {
    A_UINT8                      host_int_status;
    A_UINT8                      cpu_int_status;
    A_UINT8                      error_int_status;
    A_UINT8                      counter_int_status;
    A_UINT8                      mbox_frame;
    A_UINT8                      rx_lookahead_valid;
    A_UINT8                      hole[2];
    A_UINT32                     rx_lookahead[HTC_MAILBOX_NUM_MAX];
    A_UINT8                      int_status_enable;
    A_UINT8                      cpu_int_status_enable;
    A_UINT8                      error_status_enable;
    A_UINT8                      counter_int_status_enable;
    A_UINT8                      int_wlan;
};

struct htc_target {
    A_BOOL                       ready;
    void                        *device; /* Handle to the device instance
                                            reported by the bus driver */
    HTC_ENDPOINT                 endPoint[HTC_MAILBOX_NUM_MAX];
    HTC_REGISTER_TABLE           table;
    HTC_REG_REQUEST_LIST         regList;
};


/* ------- Function Prototypes for Receive -------- */
void
htcReceiveFrame(HTC_ENDPOINT *endPoint);

A_UINT32
htcGetFrameLength(HTC_ENDPOINT *endPoint);


/* ------- Function Prototypes for Transmit -------- */
void
htcSendFrame(HTC_ENDPOINT *endPoint);

void
htcSendBlkSize(HTC_ENDPOINT *endPoint);


/* ------- Function Prototypes for Events and Callbacks  ------- */
A_STATUS
htcRWCompletionHandler(void *element,
                       A_STATUS status);

A_STATUS
htcTxCompletionCB(HTC_DATA_REQUEST_ELEMENT *element,
                  A_STATUS status);

A_STATUS
htcBlkSzNegCompletionCB(HTC_DATA_REQUEST_ELEMENT *element,
                        A_STATUS status);

A_STATUS
htcRxCompletionCB(HTC_DATA_REQUEST_ELEMENT *element,
                  A_STATUS status);

A_STATUS
htcRegCompletionCB(HTC_REG_REQUEST_ELEMENT *element,
                   A_STATUS status);

A_STATUS
htcTargetInsertedHandler(HIF_DEVICE *device);

A_STATUS
htcTargetRemovedHandler(HIF_DEVICE *device);

A_STATUS
htcDSRHandler(HIF_DEVICE *device);

#ifdef CF
A_STATUS
htcInterruptDisabler(HIF_DEVICE *device,A_BOOL *callDsr);

A_STATUS
htcInterruptEnabler(HIF_DEVICE *device);
#endif /* CF */

void
htcServiceCPUInterrupt(HTC_TARGET *target);

void
htcServiceErrorInterrupt(HTC_TARGET *target);

void
htcServiceCounterInterrupt(HTC_TARGET *target);

void
htcServiceMailboxInterrupt(HTC_TARGET *target);

void
htcEnableCreditCounterInterrupt(HTC_TARGET *target,
                                HTC_ENDPOINT_ID endPointId);

void
htcDisableCreditCounterInterrupt(HTC_TARGET *target,
                                 HTC_ENDPOINT_ID endPointId);

/* ------- Function Prototypes for Utility routines ------- */
A_STATUS
addToMboxQueue(HTC_DATA_REQUEST_QUEUE *queue,
               A_UCHAR        *buffer,
               A_UINT32        bufferLength,
               A_UINT32        actualLength,
               void           *cookie);

HTC_DATA_REQUEST_ELEMENT *
removeFromMboxQueue(HTC_DATA_REQUEST_QUEUE *queue);

void
flushMboxQueue(HTC_ENDPOINT *endPoint,
               HTC_DATA_REQUEST_QUEUE *queue,
               HTC_EVENT_ID eventId);

HTC_REG_REQUEST_ELEMENT *
allocateRegRequestElement(HTC_TARGET *target);

void
freeRegRequestElement(HTC_REG_REQUEST_ELEMENT *element);

A_STATUS
addToEventTable(HTC_TARGET       *target,
                HTC_ENDPOINT_ID   endPointId,
                HTC_EVENT_ID      eventId,
                HTC_EVENT_HANDLER handler,
                void             *param);

A_STATUS
removeFromEventTable(HTC_TARGET *target,
                     HTC_ENDPOINT_ID endPointId,
                     HTC_EVENT_ID  eventId);

void
dispatchEvent(HTC_TARGET     *target,
              HTC_ENDPOINT_ID endPointId,
              HTC_EVENT_ID    eventId,
              HTC_EVENT_INFO *eventInfo);

HTC_TARGET *
getTargetInstance(void *device);

void
addTargetInstance(HTC_TARGET *target);

void
delTargetInstance(HTC_TARGET *target);

A_UINT32
getRegAddr(TARGET_REGISTERS base,
           HTC_ENDPOINT_ID endPointId);

A_UINT8
htcGetBitNumSet(A_UINT32 data);

void
dumpBytes(A_UCHAR *buffer, A_UINT16 length);

void
dumpRegisters(HTC_TARGET *target);

#ifdef __cplusplus
}
#endif

#endif /* _HTC_INTERNAL_H_ */