/* hit the credit counter with a 4-byte access, the first byte read will hit the counter and cause
* a decrement, while the remaining 3 bytes has no effect. The rationale behind this is to
* make all HIF accesses 4-byte aligned */
- status = HIFReadWrite(device, address, (A_UINT8 *)pBMICmdCredits, 4,
+ status = HIFReadWrite(device, address, (u8 *)pBMICmdCredits, 4,
HIF_RD_SYNC_BYTE_INC, NULL);
if (status != A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unable to decrement the command credit count register\n"));
continue;
}
- status = HIFReadWrite(device, RX_LOOKAHEAD_VALID_ADDRESS, (A_UINT8 *)&word_available,
+ status = HIFReadWrite(device, RX_LOOKAHEAD_VALID_ADDRESS, (u8 *)&word_available,
sizeof(word_available), HIF_RD_SYNC_BYTE_INC, NULL);
if (status != A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unable to read RX_LOOKAHEAD_VALID register\n"));
/* read the counter using a 4-byte read. Since the counter is NOT auto-decrementing,
* we can read this counter multiple times using a non-incrementing address mode.
* The rationale here is to make all HIF accesses a multiple of 4 bytes */
- status = HIFReadWrite(device, address, (A_UINT8 *)pBMICmdCredits, sizeof(*pBMICmdCredits),
+ status = HIFReadWrite(device, address, (u8 *)pBMICmdCredits, sizeof(*pBMICmdCredits),
HIF_RD_SYNC_BYTE_FIX, NULL);
if (status != A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unable to read the command credit count register\n"));
}
if (unalignedBytes) {
- status = BMILZData(device, (A_UINT8 *)&lastWord, 4);
+ status = BMILZData(device, (u8 *)&lastWord, 4);
}
if (!status) {
BUS_REQUEST busRequest[BUS_REQUEST_MAX_NUM]; /* available bus requests */
void *claimedContext;
HTC_CALLBACKS htcCallbacks;
- A_UINT8 *dma_buffer;
+ u8 *dma_buffer;
DL_LIST ScatterReqHead; /* scatter request list head */
bool scatter_enabled; /* scatter enabled flag */
bool is_suspend;
A_UINT32 request,
void *context)
{
- A_UINT8 opcode;
+ u8 opcode;
int status = A_OK;
int ret;
- A_UINT8 *tbuffer;
+ u8 *tbuffer;
bool bounced = false;
AR_DEBUG_ASSERT(device != NULL);
struct mmc_host *host;
struct mmc_card *card;
struct sdio_func *func;
- A_UINT8 cmd52_resp;
+ u8 cmd52_resp;
A_UINT32 clock;
func = device->func;
int hifWaitForPendingRecv(HIF_DEVICE *device)
{
A_INT32 cnt = 10;
- A_UINT8 host_int_status;
+ u8 host_int_status;
int status = A_OK;
do {
/* check if there is any pending irq due to force done */
host_int_status = 0;
status = HIFReadWrite(device, HOST_INT_STATUS_ADDRESS,
- (A_UINT8 *)&host_int_status, sizeof(host_int_status),
+ (u8 *)&host_int_status, sizeof(host_int_status),
HIF_RD_SYNC_BYTE_INC, NULL);
host_int_status = !status ? (host_int_status & (1 << 0)) : 0;
if (host_int_status) {
int DoHifReadWriteScatter(HIF_DEVICE *device, BUS_REQUEST *busrequest)
{
int i;
- A_UINT8 rw;
- A_UINT8 opcode;
+ u8 rw;
+ u8 opcode;
struct mmc_request mmcreq;
struct mmc_command cmd;
struct mmc_data data;
int DevCopyScatterListToFromDMABuffer(HIF_SCATTER_REQ *pReq, bool FromDMA)
{
- A_UINT8 *pDMABuffer = NULL;
+ u8 *pDMABuffer = NULL;
int i, remaining;
A_UINT32 length;
A_MEMZERO(pReq, sgreqSize);
/* the virtual DMA starts after the scatter request struct */
- pVirtualInfo = (DEV_SCATTER_DMA_VIRTUAL_INFO *)((A_UINT8 *)pReq + sgreqSize);
+ pVirtualInfo = (DEV_SCATTER_DMA_VIRTUAL_INFO *)((u8 *)pReq + sgreqSize);
A_MEMZERO(pVirtualInfo, sizeof(DEV_SCATTER_DMA_VIRTUAL_INFO));
pVirtualInfo->pVirtDmaBuffer = &pVirtualInfo->DataArea[0];
#define TEST_CREDITS_RECV_TIMEOUT 100
-static A_UINT8 g_Buffer[TOTAL_BYTES];
+static u8 g_Buffer[TOTAL_BYTES];
static A_UINT32 g_MailboxAddrs[AR6K_MAILBOXES];
static A_UINT32 g_BlockSizes[AR6K_MAILBOXES];
#define BUFFER_PROC_LIST_DEPTH 4
typedef struct _BUFFER_PROC_LIST{
- A_UINT8 *pBuffer;
+ u8 *pBuffer;
A_UINT32 length;
}BUFFER_PROC_LIST;
/* a simple and crude way to send different "message" sizes */
static void AssembleBufferList(BUFFER_PROC_LIST *pList)
{
- A_UINT8 *pBuffer = g_Buffer;
+ u8 *pBuffer = g_Buffer;
#if BUFFER_PROC_LIST_DEPTH < 4
#error "Buffer processing list depth is not deep enough!!"
/* find the end marker for the last buffer we will be sending */
static A_UINT16 GetEndMarker(void)
{
- A_UINT8 *pBuffer;
+ u8 *pBuffer;
BUFFER_PROC_LIST checkList[BUFFER_PROC_LIST_DEPTH];
/* fill up buffers with the normal counting pattern */
{
int status = A_OK;
int timeout = TEST_CREDITS_RECV_TIMEOUT;
- A_UINT8 credits = 0;
+ u8 credits = 0;
A_UINT32 address;
while (true) {
int i;
int status;
int credits = 0;
- A_UINT8 params[4];
+ u8 params[4];
int numBufs;
int bufferSize;
A_UINT16 temp;
status = HIFReadWrite(pDev->HIFDevice,
SCRATCH_ADDRESS + 4,
- (A_UINT8 *)&temp,
+ (u8 *)&temp,
2,
HIF_WR_SYNC_BYTE_INC,
NULL);
temp = temp - 1;
status = HIFReadWrite(pDev->HIFDevice,
SCRATCH_ADDRESS + 6,
- (A_UINT8 *)&temp,
+ (u8 *)&temp,
2,
HIF_WR_SYNC_BYTE_INC,
NULL);
#include "athstartpack.h"
typedef PREPACK struct _AR6K_IRQ_PROC_REGISTERS {
- 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 host_int_status2;
- A_UINT8 gmbox_rx_avail;
+ u8 host_int_status;
+ u8 cpu_int_status;
+ u8 error_int_status;
+ u8 counter_int_status;
+ u8 mbox_frame;
+ u8 rx_lookahead_valid;
+ u8 host_int_status2;
+ u8 gmbox_rx_avail;
A_UINT32 rx_lookahead[2];
A_UINT32 rx_gmbox_lookahead_alias[2];
} POSTPACK AR6K_IRQ_PROC_REGISTERS;
#define AR6K_IRQ_PROC_REGS_SIZE sizeof(AR6K_IRQ_PROC_REGISTERS)
typedef PREPACK struct _AR6K_IRQ_ENABLE_REGISTERS {
- A_UINT8 int_status_enable;
- A_UINT8 cpu_int_status_enable;
- A_UINT8 error_status_enable;
- A_UINT8 counter_int_status_enable;
+ u8 int_status_enable;
+ u8 cpu_int_status_enable;
+ u8 error_status_enable;
+ u8 counter_int_status_enable;
} POSTPACK AR6K_IRQ_ENABLE_REGISTERS;
typedef PREPACK struct _AR6K_GMBOX_CTRL_REGISTERS {
- A_UINT8 int_status_enable;
+ u8 int_status_enable;
} POSTPACK AR6K_GMBOX_CTRL_REGISTERS;
#include "athendpack.h"
/* buffers for ASYNC I/O */
typedef struct AR6K_ASYNC_REG_IO_BUFFER {
HTC_PACKET HtcPacket; /* we use an HTC packet as a wrapper for our async register-based I/O */
- A_UINT8 _Pad1[A_CACHE_LINE_PAD];
- A_UINT8 Buffer[AR6K_REG_IO_BUFFER_SIZE]; /* cache-line safe with pads around */
- A_UINT8 _Pad2[A_CACHE_LINE_PAD];
+ u8 _Pad1[A_CACHE_LINE_PAD];
+ u8 Buffer[AR6K_REG_IO_BUFFER_SIZE]; /* cache-line safe with pads around */
+ u8 _Pad2[A_CACHE_LINE_PAD];
} AR6K_ASYNC_REG_IO_BUFFER;
typedef struct _AR6K_GMBOX_INFO {
void *pProtocolContext;
- int (*pMessagePendingCallBack)(void *pContext, A_UINT8 LookAheadBytes[], int ValidBytes);
+ int (*pMessagePendingCallBack)(void *pContext, u8 LookAheadBytes[], int ValidBytes);
int (*pCreditsPendingCallback)(void *pContext, int NumCredits, bool CreditIRQEnabled);
void (*pTargetFailureCallback)(void *pContext, int Status);
void (*pStateDumpCallback)(void *pContext);
typedef struct _AR6K_DEVICE {
A_MUTEX_T Lock;
- A_UINT8 _Pad1[A_CACHE_LINE_PAD];
+ u8 _Pad1[A_CACHE_LINE_PAD];
AR6K_IRQ_PROC_REGISTERS IrqProcRegisters; /* cache-line safe with pads around */
- A_UINT8 _Pad2[A_CACHE_LINE_PAD];
+ u8 _Pad2[A_CACHE_LINE_PAD];
AR6K_IRQ_ENABLE_REGISTERS IrqEnableRegisters; /* cache-line safe with pads around */
- A_UINT8 _Pad3[A_CACHE_LINE_PAD];
+ u8 _Pad3[A_CACHE_LINE_PAD];
void *HIFDevice;
A_UINT32 BlockSize;
A_UINT32 BlockMask;
/* completely virtual */
typedef struct _DEV_SCATTER_DMA_VIRTUAL_INFO {
- A_UINT8 *pVirtDmaBuffer; /* dma-able buffer - CPU accessible address */
- A_UINT8 DataArea[1]; /* start of data area */
+ u8 *pVirtDmaBuffer; /* dma-able buffer - CPU accessible address */
+ u8 DataArea[1]; /* start of data area */
} DEV_SCATTER_DMA_VIRTUAL_INFO;
int DevGMboxIRQAction(AR6K_DEVICE *pDev, GMBOX_IRQ_ACTION_TYPE, bool AsyncMode);
int DevGMboxReadCreditCounter(AR6K_DEVICE *pDev, bool AsyncMode, int *pCredits);
int DevGMboxReadCreditSize(AR6K_DEVICE *pDev, int *pCreditSize);
-int DevGMboxRecvLookAheadPeek(AR6K_DEVICE *pDev, A_UINT8 *pLookAheadBuffer, int *pLookAheadBytes);
+int DevGMboxRecvLookAheadPeek(AR6K_DEVICE *pDev, u8 *pLookAheadBuffer, int *pLookAheadBytes);
int DevGMboxSetTargetInterrupt(AR6K_DEVICE *pDev, int SignalNumber, int AckTimeoutMS);
#endif
/* load the register table */
status = HIFReadWrite(pDev->HIFDevice,
HOST_INT_STATUS_ADDRESS,
- (A_UINT8 *)&pDev->IrqProcRegisters,
+ (u8 *)&pDev->IrqProcRegisters,
AR6K_IRQ_PROC_REGS_SIZE,
HIF_RD_SYNC_BYTE_INC,
NULL);
static int DevServiceCPUInterrupt(AR6K_DEVICE *pDev)
{
int status;
- A_UINT8 cpu_int_status;
- A_UINT8 regBuffer[4];
+ u8 cpu_int_status;
+ u8 regBuffer[4];
AR_DEBUG_PRINTF(ATH_DEBUG_IRQ, ("CPU Interrupt\n"));
cpu_int_status = pDev->IrqProcRegisters.cpu_int_status &
static int DevServiceErrorInterrupt(AR6K_DEVICE *pDev)
{
int status;
- A_UINT8 error_int_status;
- A_UINT8 regBuffer[4];
+ u8 error_int_status;
+ u8 regBuffer[4];
AR_DEBUG_PRINTF(ATH_DEBUG_IRQ, ("Error Interrupt\n"));
error_int_status = pDev->IrqProcRegisters.error_int_status & 0x0F;
/* read counter to clear interrupt */
status = HIFReadWrite(pDev->HIFDevice,
COUNT_DEC_ADDRESS,
- (A_UINT8 *)&dummy,
+ (u8 *)&dummy,
4,
HIF_RD_SYNC_BYTE_INC,
NULL);
static int DevServiceCounterInterrupt(AR6K_DEVICE *pDev)
{
- A_UINT8 counter_int_status;
+ u8 counter_int_status;
AR_DEBUG_PRINTF(ATH_DEBUG_IRQ, ("Counter Interrupt\n"));
} else {
/* standard interrupt table handling.... */
AR6K_IRQ_PROC_REGISTERS *pReg = (AR6K_IRQ_PROC_REGISTERS *)pPacket->pBuffer;
- A_UINT8 host_int_status;
+ u8 host_int_status;
host_int_status = pReg->host_int_status & pDev->IrqEnableRegisters.int_status_enable;
static int ProcessPendingIRQs(AR6K_DEVICE *pDev, bool *pDone, bool *pASyncProcessing)
{
int status = A_OK;
- A_UINT8 host_int_status = 0;
+ u8 host_int_status = 0;
A_UINT32 lookAhead = 0;
AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("+ProcessPendingIRQs: (dev: 0x%lX)\n", (unsigned long)pDev));
#endif /* CONFIG_MMC_SDHCI_S3C */
status = HIFReadWrite(pDev->HIFDevice,
HOST_INT_STATUS_ADDRESS,
- (A_UINT8 *)&pDev->IrqProcRegisters,
+ (u8 *)&pDev->IrqProcRegisters,
AR6K_IRQ_PROC_REGS_SIZE,
HIF_RD_SYNC_BYTE_INC,
NULL);
/* load the register table from the device */
status = HIFReadWrite(pDev->HIFDevice,
HOST_INT_STATUS_ADDRESS,
- (A_UINT8 *)&procRegs,
+ (u8 *)&procRegs,
AR6K_IRQ_PROC_REGS_SIZE,
HIF_RD_SYNC_BYTE_INC,
NULL);
{
int status = A_OK;
HTC_PACKET *pIOPacket = NULL;
- A_UINT8 GMboxIntControl[4];
+ u8 GMboxIntControl[4];
if (GMBOX_CREDIT_IRQ_ENABLE == IrqAction) {
return DevGMboxCounterEnableDisable(pDev, GMBOX_CREDIT_IRQ_ENABLE, AsyncMode);
int DevSetupGMbox(AR6K_DEVICE *pDev)
{
int status = A_OK;
- A_UINT8 muxControl[4];
+ u8 muxControl[4];
do {
int DevCheckGMboxInterrupts(AR6K_DEVICE *pDev)
{
int status = A_OK;
- A_UINT8 counter_int_status;
+ u8 counter_int_status;
int credits;
- A_UINT8 host_int_status2;
+ u8 host_int_status2;
AR_DEBUG_PRINTF(ATH_DEBUG_IRQ, ("+DevCheckGMboxInterrupts \n"));
A_ASSERT(pDev->GMboxInfo.pMessagePendingCallBack != NULL);
status = pDev->GMboxInfo.pMessagePendingCallBack(
pDev->GMboxInfo.pProtocolContext,
- (A_UINT8 *)&pDev->IrqProcRegisters.rx_gmbox_lookahead_alias[0],
+ (u8 *)&pDev->IrqProcRegisters.rx_gmbox_lookahead_alias[0],
pDev->IrqProcRegisters.gmbox_rx_avail);
}
}
}
-static int ProcessCreditCounterReadBuffer(A_UINT8 *pBuffer, int Length)
+static int ProcessCreditCounterReadBuffer(u8 *pBuffer, int Length)
{
int credits = 0;
int DevGMboxReadCreditSize(AR6K_DEVICE *pDev, int *pCreditSize)
{
int status;
- A_UINT8 buffer[4];
+ u8 buffer[4];
status = HIFReadWrite(pDev->HIFDevice,
AR6K_GMBOX_CREDIT_SIZE_ADDRESS,
}
}
-int DevGMboxRecvLookAheadPeek(AR6K_DEVICE *pDev, A_UINT8 *pLookAheadBuffer, int *pLookAheadBytes)
+int DevGMboxRecvLookAheadPeek(AR6K_DEVICE *pDev, u8 *pLookAheadBuffer, int *pLookAheadBytes)
{
int status = A_OK;
/* load the register table from the device */
status = HIFReadWrite(pDev->HIFDevice,
HOST_INT_STATUS_ADDRESS,
- (A_UINT8 *)&procRegs,
+ (u8 *)&procRegs,
AR6K_IRQ_PROC_REGS_SIZE,
HIF_RD_SYNC_BYTE_INC,
NULL);
{
int status = A_OK;
int i;
- A_UINT8 buffer[4];
+ u8 buffer[4];
A_MEMZERO(buffer, sizeof(buffer));
AR_DEBUG_PRINTF(ATH_DEBUG_ANY,("==================================================\n"));
}
-static int HCIUartMessagePending(void *pContext, A_UINT8 LookAheadBytes[], int ValidBytes)
+static int HCIUartMessagePending(void *pContext, u8 LookAheadBytes[], int ValidBytes)
{
GMBOX_PROTO_HCI_UART *pProt = (GMBOX_PROTO_HCI_UART *)pContext;
int status = A_OK;
int status = A_OK;
int transferLength;
int creditsRequired, remainder;
- A_UINT8 hciUartType;
+ u8 hciUartType;
bool synchSendComplete = false;
AR_DEBUG_PRINTF(ATH_DEBUG_SEND,("+HCITrySend (pPacket:0x%lX) %s \n",(unsigned long)pPacket,
{
GMBOX_PROTO_HCI_UART *pProt = (GMBOX_PROTO_HCI_UART *)HciTrans;
int status = A_OK;
- A_UINT8 lookAhead[8];
+ u8 lookAhead[8];
int bytes;
int totalRecvLength;
HTC_PACKET_QUEUE RecvIndicationQueue; /* recv packets ready to be indicated */
int RxProcessCount; /* reference count to allow single processing context */
struct _HTC_TARGET *target; /* back pointer to target */
- A_UINT8 SeqNo; /* TX seq no (helpful) for debugging */
+ u8 SeqNo; /* TX seq no (helpful) for debugging */
A_UINT32 LocalConnectionFlags; /* local connection flags */
#ifdef HTC_EP_STAT_PROFILING
HTC_ENDPOINT_STATS EndPointStats; /* endpoint statistics */
typedef struct HTC_CONTROL_BUFFER {
HTC_PACKET HtcPacket;
- A_UINT8 *Buffer;
+ u8 *Buffer;
} HTC_CONTROL_BUFFER;
#define HTC_RECV_WAIT_BUFFERS (1 << 0)
bool TargetFailure;
#ifdef HTC_CAPTURE_LAST_FRAME
HTC_FRAME_HDR LastFrameHdr; /* useful for debugging */
- A_UINT8 LastTrailer[256];
- A_UINT8 LastTrailerLength;
+ u8 LastTrailer[256];
+ u8 LastTrailerLength;
#endif
HTC_INIT_INFO HTCInitInfo;
- A_UINT8 HTCTargetVersion;
+ u8 HTCTargetVersion;
int MaxMsgPerBundle; /* max messages per bundle for HTC */
bool SendBundlingEnabled; /* run time enable for send bundling (dynamic) */
int RecvBundlingEnabled; /* run time enable for recv bundling (dynamic) */
#define HTC_PREPARE_SEND_PKT(pP,sendflags,ctrl0,ctrl1) \
{ \
- A_UINT8 *pHdrBuf; \
+ u8 *pHdrBuf; \
(pP)->pBuffer -= HTC_HDR_LENGTH; \
pHdrBuf = (pP)->pBuffer; \
A_SET_UINT16_FIELD(pHdrBuf,HTC_FRAME_HDR,PayloadLen,(A_UINT16)(pP)->ActualLength); \
A_SET_UINT8_FIELD(pHdrBuf,HTC_FRAME_HDR,Flags,(sendflags)); \
- A_SET_UINT8_FIELD(pHdrBuf,HTC_FRAME_HDR,EndpointID, (A_UINT8)(pP)->Endpoint); \
- A_SET_UINT8_FIELD(pHdrBuf,HTC_FRAME_HDR,ControlBytes[0], (A_UINT8)(ctrl0)); \
- A_SET_UINT8_FIELD(pHdrBuf,HTC_FRAME_HDR,ControlBytes[1], (A_UINT8)(ctrl1)); \
+ A_SET_UINT8_FIELD(pHdrBuf,HTC_FRAME_HDR,EndpointID, (u8)(pP)->Endpoint); \
+ A_SET_UINT8_FIELD(pHdrBuf,HTC_FRAME_HDR,ControlBytes[0], (u8)(ctrl0)); \
+ A_SET_UINT8_FIELD(pHdrBuf,HTC_FRAME_HDR,ControlBytes[1], (u8)(ctrl1)); \
}
#define HTC_UNPREPARE_SEND_PKT(pP) \
}
static INLINE int HTCProcessTrailer(HTC_TARGET *target,
- A_UINT8 *pBuffer,
+ u8 *pBuffer,
int Length,
A_UINT32 *pNextLookAheads,
int *pNumLookAheads,
HTC_ENDPOINT_ID FromEndpoint)
{
HTC_RECORD_HDR *pRecord;
- A_UINT8 *pRecordBuf;
+ u8 *pRecordBuf;
HTC_LOOKAHEAD_REPORT *pLookAhead;
- A_UINT8 *pOrigBuffer;
+ u8 *pOrigBuffer;
int origLength;
int status;
pLookAhead->PostValid));
/* look ahead bytes are valid, copy them over */
- ((A_UINT8 *)(&pNextLookAheads[0]))[0] = pLookAhead->LookAhead[0];
- ((A_UINT8 *)(&pNextLookAheads[0]))[1] = pLookAhead->LookAhead[1];
- ((A_UINT8 *)(&pNextLookAheads[0]))[2] = pLookAhead->LookAhead[2];
- ((A_UINT8 *)(&pNextLookAheads[0]))[3] = pLookAhead->LookAhead[3];
+ ((u8 *)(&pNextLookAheads[0]))[0] = pLookAhead->LookAhead[0];
+ ((u8 *)(&pNextLookAheads[0]))[1] = pLookAhead->LookAhead[1];
+ ((u8 *)(&pNextLookAheads[0]))[2] = pLookAhead->LookAhead[2];
+ ((u8 *)(&pNextLookAheads[0]))[3] = pLookAhead->LookAhead[3];
#ifdef ATH_DEBUG_MODULE
if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_RECV)) {
- DebugDumpBytes((A_UINT8 *)pNextLookAheads,4,"Next Look Ahead");
+ DebugDumpBytes((u8 *)pNextLookAheads,4,"Next Look Ahead");
}
#endif
/* just one normal lookahead */
}
for (i = 0; i < (int)(pRecord->Length / (sizeof(HTC_BUNDLED_LOOKAHEAD_REPORT))); i++) {
- ((A_UINT8 *)(&pNextLookAheads[i]))[0] = pBundledLookAheadRpt->LookAhead[0];
- ((A_UINT8 *)(&pNextLookAheads[i]))[1] = pBundledLookAheadRpt->LookAhead[1];
- ((A_UINT8 *)(&pNextLookAheads[i]))[2] = pBundledLookAheadRpt->LookAhead[2];
- ((A_UINT8 *)(&pNextLookAheads[i]))[3] = pBundledLookAheadRpt->LookAhead[3];
+ ((u8 *)(&pNextLookAheads[i]))[0] = pBundledLookAheadRpt->LookAhead[0];
+ ((u8 *)(&pNextLookAheads[i]))[1] = pBundledLookAheadRpt->LookAhead[1];
+ ((u8 *)(&pNextLookAheads[i]))[2] = pBundledLookAheadRpt->LookAhead[2];
+ ((u8 *)(&pNextLookAheads[i]))[3] = pBundledLookAheadRpt->LookAhead[3];
pBundledLookAheadRpt++;
}
A_UINT32 *pNextLookAheads,
int *pNumLookAheads)
{
- A_UINT8 temp;
- A_UINT8 *pBuf;
+ u8 temp;
+ u8 *pBuf;
int status = A_OK;
A_UINT16 payloadLen;
A_UINT32 lookAhead;
* retrieve 16 bit fields */
payloadLen = A_GET_UINT16_FIELD(pBuf, HTC_FRAME_HDR, PayloadLen);
- ((A_UINT8 *)&lookAhead)[0] = pBuf[0];
- ((A_UINT8 *)&lookAhead)[1] = pBuf[1];
- ((A_UINT8 *)&lookAhead)[2] = pBuf[2];
- ((A_UINT8 *)&lookAhead)[3] = pBuf[3];
+ ((u8 *)&lookAhead)[0] = pBuf[0];
+ ((u8 *)&lookAhead)[1] = pBuf[1];
+ ((u8 *)&lookAhead)[2] = pBuf[2];
+ ((u8 *)&lookAhead)[3] = pBuf[3];
if (pPacket->PktInfo.AsRx.HTCRxFlags & HTC_RX_PKT_REFRESH_HDR) {
/* refresh expected hdr, since this was unknown at the time we grabbed the packets
("HTCProcessRecvHeader, lookahead mismatch! (pPkt:0x%lX flags:0x%X) \n",
(unsigned long)pPacket, pPacket->PktInfo.AsRx.HTCRxFlags));
#ifdef ATH_DEBUG_MODULE
- DebugDumpBytes((A_UINT8 *)&pPacket->PktInfo.AsRx.ExpectedHdr,4,"Expected Message LookAhead");
+ DebugDumpBytes((u8 *)&pPacket->PktInfo.AsRx.ExpectedHdr,4,"Expected Message LookAhead");
DebugDumpBytes(pBuf,sizeof(HTC_FRAME_HDR),"Current Frame Header");
#ifdef HTC_CAPTURE_LAST_FRAME
- DebugDumpBytes((A_UINT8 *)&target->LastFrameHdr,sizeof(HTC_FRAME_HDR),"Last Frame Header");
+ DebugDumpBytes((u8 *)&target->LastFrameHdr,sizeof(HTC_FRAME_HDR),"Last Frame Header");
if (target->LastTrailerLength != 0) {
DebugDumpBytes(target->LastTrailer,
target->LastTrailerLength,
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("Next look ahead from recv header was INVALID\n"));
#ifdef ATH_DEBUG_MODULE
- DebugDumpBytes((A_UINT8 *)NextLookAheads,
+ DebugDumpBytes((u8 *)NextLookAheads,
NumLookAheads * (sizeof(A_UINT32)),
"BAD lookaheads from lookahead report");
#endif
{
int creditsRequired;
int remainder;
- A_UINT8 sendFlags;
+ u8 sendFlags;
HTC_PACKET *pPacket;
unsigned int transferLength;
A_MEMCPY(&pSetupCompleteEx->SetupFlags, &setupFlags, sizeof(pSetupCompleteEx->SetupFlags));
SET_HTC_PACKET_INFO_TX(pSendPacket,
NULL,
- (A_UINT8 *)pSetupCompleteEx,
+ (u8 *)pSetupCompleteEx,
sizeof(HTC_SETUP_COMPLETE_EX_MSG),
ENDPOINT_0,
HTC_SERVICE_TX_PACKET_TAG);
pSetupComplete->MessageID = HTC_MSG_SETUP_COMPLETE_ID;
SET_HTC_PACKET_INFO_TX(pSendPacket,
NULL,
- (A_UINT8 *)pSetupComplete,
+ (u8 *)pSetupComplete,
sizeof(HTC_SETUP_COMPLETE_MSG),
ENDPOINT_0,
HTC_SERVICE_TX_PACKET_TAG);
if ((pConnectReq->pMetaData != NULL) &&
(pConnectReq->MetaDataLength <= HTC_SERVICE_META_DATA_MAX_LENGTH)) {
/* copy meta data into message buffer (after header ) */
- A_MEMCPY((A_UINT8 *)pConnectMsg + sizeof(HTC_CONNECT_SERVICE_MSG),
+ A_MEMCPY((u8 *)pConnectMsg + sizeof(HTC_CONNECT_SERVICE_MSG),
pConnectReq->pMetaData,
pConnectReq->MetaDataLength);
pConnectMsg->ServiceMetaLength = pConnectReq->MetaDataLength;
SET_HTC_PACKET_INFO_TX(pSendPacket,
NULL,
- (A_UINT8 *)pConnectMsg,
+ (u8 *)pConnectMsg,
sizeof(HTC_CONNECT_SERVICE_MSG) + pConnectMsg->ServiceMetaLength,
ENDPOINT_0,
HTC_SERVICE_TX_PACKET_TAG);
int copyLength = min((int)pConnectResp->BufferLength, (int)pResponseMsg->ServiceMetaLength);
/* copy the meta data */
A_MEMCPY(pConnectResp->pMetaData,
- ((A_UINT8 *)pResponseMsg) + sizeof(HTC_CONNECT_SERVICE_RESPONSE_MSG),
+ ((u8 *)pResponseMsg) + sizeof(HTC_CONNECT_SERVICE_RESPONSE_MSG),
copyLength);
pConnectResp->ActualLength = copyLength;
}
* up to the indicated sequence number.
*/
void
-aggr_process_bar(void *cntxt, A_UINT8 tid, A_UINT16 seq_no);
+aggr_process_bar(void *cntxt, u8 tid, A_UINT16 seq_no);
/*
* in hold_q to OS.
*/
void
-aggr_recv_addba_req_evt(void * cntxt, A_UINT8 tid, A_UINT16 seq_no, A_UINT8 win_sz);
+aggr_recv_addba_req_evt(void * cntxt, u8 tid, A_UINT16 seq_no, u8 win_sz);
/*
* aggr is not enabled on any tid.
*/
void
-aggr_recv_delba_req_evt(void * cntxt, A_UINT8 tid);
+aggr_recv_delba_req_evt(void * cntxt, u8 tid);
* callback may be called to deliver frames in order.
*/
void
-aggr_process_recv_frm(void *cntxt, A_UINT8 tid, A_UINT16 seq_no, bool is_amsdu, void **osbuf);
+aggr_process_recv_frm(void *cntxt, u8 tid, A_UINT16 seq_no, bool is_amsdu, void **osbuf);
/*
A_UINT32 PwrMgmtEnabled; /* TLPM enabled? */
A_UINT16 IdleTimeout; /* TLPM idle timeout */
A_UINT16 WakeupTimeout; /* TLPM wakeup timeout */
- A_UINT8 bdaddr[6]; /* Bluetooth device address */
+ u8 bdaddr[6]; /* Bluetooth device address */
} AR3K_CONFIG_INFO;
int AR3KConfigure(AR3K_CONFIG_INFO *pConfigInfo);
* Used with AR6000_XIOCTL_AP_GET_STA_LIST
*/
typedef struct {
- A_UINT8 mac[ATH_MAC_LEN];
- A_UINT8 aid;
- A_UINT8 keymgmt;
- A_UINT8 ucipher;
- A_UINT8 auth;
+ u8 mac[ATH_MAC_LEN];
+ u8 aid;
+ u8 keymgmt;
+ u8 ucipher;
+ u8 auth;
} station_t;
typedef struct {
station_t sta[AP_MAX_NUM_STA];
/* Command pkt */
typedef struct hci_cmd_pkt_t {
A_UINT16 opcode;
- A_UINT8 param_length;
- A_UINT8 params[255];
+ u8 param_length;
+ u8 params[255];
} POSTPACK HCI_CMD_PKT;
#define ACL_DATA_HDR_SIZE 4 /* hdl_and flags + data_len */
typedef struct hci_acl_data_pkt_t {
A_UINT16 hdl_and_flags;
A_UINT16 data_len;
- A_UINT8 data[Max80211_PAL_PDU_Size];
+ u8 data[Max80211_PAL_PDU_Size];
} POSTPACK HCI_ACL_DATA_PKT;
/* Event pkt */
typedef struct hci_event_pkt_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 params[256];
+ u8 event_code;
+ u8 param_len;
+ u8 params[256];
} POSTPACK HCI_EVENT_PKT;
/*============== HCI Command definitions ======================= */
typedef struct hci_cmd_phy_link_t {
A_UINT16 opcode;
- A_UINT8 param_length;
- A_UINT8 phy_link_hdl;
- A_UINT8 link_key_len;
- A_UINT8 link_key_type;
- A_UINT8 link_key[LINK_KEY_LEN];
+ u8 param_length;
+ u8 phy_link_hdl;
+ u8 link_key_len;
+ u8 link_key_type;
+ u8 link_key[LINK_KEY_LEN];
} POSTPACK HCI_CMD_PHY_LINK;
typedef struct hci_cmd_write_rem_amp_assoc_t {
A_UINT16 opcode;
- A_UINT8 param_length;
- A_UINT8 phy_link_hdl;
+ u8 param_length;
+ u8 phy_link_hdl;
A_UINT16 len_so_far;
A_UINT16 amp_assoc_remaining_len;
- A_UINT8 amp_assoc_frag[AMP_ASSOC_MAX_FRAG_SZ];
+ u8 amp_assoc_frag[AMP_ASSOC_MAX_FRAG_SZ];
} POSTPACK HCI_CMD_WRITE_REM_AMP_ASSOC;
typedef struct hci_cmd_opcode_hdl_t {
A_UINT16 opcode;
- A_UINT8 param_length;
+ u8 param_length;
A_UINT16 hdl;
} POSTPACK HCI_CMD_READ_LINK_QUAL,
HCI_CMD_FLUSH,
typedef struct hci_cmd_read_local_amp_assoc_t {
A_UINT16 opcode;
- A_UINT8 param_length;
- A_UINT8 phy_link_hdl;
+ u8 param_length;
+ u8 phy_link_hdl;
A_UINT16 len_so_far;
A_UINT16 max_rem_amp_assoc_len;
} POSTPACK HCI_CMD_READ_LOCAL_AMP_ASSOC;
typedef struct hci_cmd_set_event_mask_t {
A_UINT16 opcode;
- A_UINT8 param_length;
+ u8 param_length;
A_UINT64 mask;
}POSTPACK HCI_CMD_SET_EVT_MASK, HCI_CMD_SET_EVT_MASK_PG_2;
typedef struct hci_cmd_enhanced_flush_t{
A_UINT16 opcode;
- A_UINT8 param_length;
+ u8 param_length;
A_UINT16 hdl;
- A_UINT8 type;
+ u8 type;
} POSTPACK HCI_CMD_ENHANCED_FLUSH;
typedef struct hci_cmd_write_timeout_t {
A_UINT16 opcode;
- A_UINT8 param_length;
+ u8 param_length;
A_UINT16 timeout;
} POSTPACK HCI_CMD_WRITE_TIMEOUT;
typedef struct hci_cmd_write_link_supervision_timeout_t {
A_UINT16 opcode;
- A_UINT8 param_length;
+ u8 param_length;
A_UINT16 hdl;
A_UINT16 timeout;
} POSTPACK HCI_CMD_WRITE_LINK_SUPERVISION_TIMEOUT;
typedef struct hci_cmd_write_flow_control_t {
A_UINT16 opcode;
- A_UINT8 param_length;
- A_UINT8 mode;
+ u8 param_length;
+ u8 mode;
} POSTPACK HCI_CMD_WRITE_FLOW_CONTROL;
typedef struct location_data_cfg_t {
- A_UINT8 reg_domain_aware;
- A_UINT8 reg_domain[3];
- A_UINT8 reg_options;
+ u8 reg_domain_aware;
+ u8 reg_domain[3];
+ u8 reg_options;
} POSTPACK LOCATION_DATA_CFG;
typedef struct hci_cmd_write_location_data_t {
A_UINT16 opcode;
- A_UINT8 param_length;
+ u8 param_length;
LOCATION_DATA_CFG cfg;
} POSTPACK HCI_CMD_WRITE_LOCATION_DATA;
typedef struct flow_spec_t {
- A_UINT8 id;
- A_UINT8 service_type;
+ u8 id;
+ u8 service_type;
A_UINT16 max_sdu;
A_UINT32 sdu_inter_arrival_time;
A_UINT32 access_latency;
typedef struct hci_cmd_create_logical_link_t {
A_UINT16 opcode;
- A_UINT8 param_length;
- A_UINT8 phy_link_hdl;
+ u8 param_length;
+ u8 phy_link_hdl;
FLOW_SPEC tx_flow_spec;
FLOW_SPEC rx_flow_spec;
} POSTPACK HCI_CMD_CREATE_LOGICAL_LINK;
typedef struct hci_cmd_flow_spec_modify_t {
A_UINT16 opcode;
- A_UINT8 param_length;
+ u8 param_length;
A_UINT16 hdl;
FLOW_SPEC tx_flow_spec;
FLOW_SPEC rx_flow_spec;
typedef struct hci_cmd_logical_link_cancel_t {
A_UINT16 opcode;
- A_UINT8 param_length;
- A_UINT8 phy_link_hdl;
- A_UINT8 tx_flow_spec_id;
+ u8 param_length;
+ u8 phy_link_hdl;
+ u8 tx_flow_spec_id;
} POSTPACK HCI_CMD_LOGICAL_LINK_CANCEL;
typedef struct hci_cmd_disconnect_logical_link_t {
A_UINT16 opcode;
- A_UINT8 param_length;
+ u8 param_length;
A_UINT16 logical_link_hdl;
} POSTPACK HCI_CMD_DISCONNECT_LOGICAL_LINK;
typedef struct hci_cmd_disconnect_phy_link_t {
A_UINT16 opcode;
- A_UINT8 param_length;
- A_UINT8 phy_link_hdl;
+ u8 param_length;
+ u8 phy_link_hdl;
} POSTPACK HCI_CMD_DISCONNECT_PHY_LINK;
typedef struct hci_cmd_srm_t {
A_UINT16 opcode;
- A_UINT8 param_length;
- A_UINT8 phy_link_hdl;
- A_UINT8 mode;
+ u8 param_length;
+ u8 phy_link_hdl;
+ u8 mode;
} POSTPACK HCI_CMD_SHORT_RANGE_MODE;
/*============== HCI Command definitions end ======================= */
/* Command complete event */
typedef struct hci_event_cmd_complete_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 num_hci_cmd_pkts;
+ u8 event_code;
+ u8 param_len;
+ u8 num_hci_cmd_pkts;
A_UINT16 opcode;
- A_UINT8 params[255];
+ u8 params[255];
} POSTPACK HCI_EVENT_CMD_COMPLETE;
/* Command status event */
typedef struct hci_event_cmd_status_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 status;
- A_UINT8 num_hci_cmd_pkts;
+ u8 event_code;
+ u8 param_len;
+ u8 status;
+ u8 num_hci_cmd_pkts;
A_UINT16 opcode;
} POSTPACK HCI_EVENT_CMD_STATUS;
/* Hardware Error event */
typedef struct hci_event_hw_err_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 hw_err_code;
+ u8 event_code;
+ u8 param_len;
+ u8 hw_err_code;
} POSTPACK HCI_EVENT_HW_ERR;
/* Flush occured event */
/* Qos Violation event */
typedef struct hci_event_handle_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
+ u8 event_code;
+ u8 param_len;
A_UINT16 handle;
} POSTPACK HCI_EVENT_FLUSH_OCCRD,
HCI_EVENT_QOS_VIOLATION;
/* Loopback command event */
typedef struct hci_loopback_cmd_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 params[252];
+ u8 event_code;
+ u8 param_len;
+ u8 params[252];
} POSTPACK HCI_EVENT_LOOPBACK_CMD;
/* Data buffer overflow event */
typedef struct hci_data_buf_overflow_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 link_type;
+ u8 event_code;
+ u8 param_len;
+ u8 link_type;
} POSTPACK HCI_EVENT_DATA_BUF_OVERFLOW;
/* Enhanced Flush complete event */
typedef struct hci_enhanced_flush_complt_t{
- A_UINT8 event_code;
- A_UINT8 param_len;
+ u8 event_code;
+ u8 param_len;
A_UINT16 hdl;
} POSTPACK HCI_EVENT_ENHANCED_FLUSH_COMPLT;
/* Channel select event */
typedef struct hci_event_chan_select_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 phy_link_hdl;
+ u8 event_code;
+ u8 param_len;
+ u8 phy_link_hdl;
} POSTPACK HCI_EVENT_CHAN_SELECT;
/* Physical Link Complete event */
typedef struct hci_event_phy_link_complete_event_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 status;
- A_UINT8 phy_link_hdl;
+ u8 event_code;
+ u8 param_len;
+ u8 status;
+ u8 phy_link_hdl;
} POSTPACK HCI_EVENT_PHY_LINK_COMPLETE;
/* Logical Link complete event */
typedef struct hci_event_logical_link_complete_event_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 status;
+ u8 event_code;
+ u8 param_len;
+ u8 status;
A_UINT16 logical_link_hdl;
- A_UINT8 phy_hdl;
- A_UINT8 tx_flow_id;
+ u8 phy_hdl;
+ u8 tx_flow_id;
} POSTPACK HCI_EVENT_LOGICAL_LINK_COMPLETE_EVENT;
/* Disconnect Logical Link complete event */
typedef struct hci_event_disconnect_logical_link_event_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 status;
+ u8 event_code;
+ u8 param_len;
+ u8 status;
A_UINT16 logical_link_hdl;
- A_UINT8 reason;
+ u8 reason;
} POSTPACK HCI_EVENT_DISCONNECT_LOGICAL_LINK_EVENT;
/* Disconnect Physical Link complete event */
typedef struct hci_event_disconnect_phy_link_complete_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 status;
- A_UINT8 phy_link_hdl;
- A_UINT8 reason;
+ u8 event_code;
+ u8 param_len;
+ u8 status;
+ u8 phy_link_hdl;
+ u8 reason;
} POSTPACK HCI_EVENT_DISCONNECT_PHY_LINK_COMPLETE;
typedef struct hci_event_physical_link_loss_early_warning_t{
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 phy_hdl;
- A_UINT8 reason;
+ u8 event_code;
+ u8 param_len;
+ u8 phy_hdl;
+ u8 reason;
} POSTPACK HCI_EVENT_PHY_LINK_LOSS_EARLY_WARNING;
typedef struct hci_event_physical_link_recovery_t{
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 phy_hdl;
+ u8 event_code;
+ u8 param_len;
+ u8 phy_hdl;
} POSTPACK HCI_EVENT_PHY_LINK_RECOVERY;
/* Flow spec modify complete event */
/* Flush event */
typedef struct hci_event_status_handle_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 status;
+ u8 event_code;
+ u8 param_len;
+ u8 status;
A_UINT16 handle;
} POSTPACK HCI_EVENT_FLOW_SPEC_MODIFY,
HCI_EVENT_FLUSH;
/* Num of completed data blocks event */
typedef struct hci_event_num_of_compl_data_blks_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
+ u8 event_code;
+ u8 param_len;
A_UINT16 num_data_blks;
- A_UINT8 num_handles;
- A_UINT8 params[255];
+ u8 num_handles;
+ u8 params[255];
} POSTPACK HCI_EVENT_NUM_COMPL_DATA_BLKS;
/* Short range mode change complete event */
typedef struct hci_srm_cmpl_t {
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 status;
- A_UINT8 phy_link;
- A_UINT8 state;
+ u8 event_code;
+ u8 param_len;
+ u8 status;
+ u8 phy_link;
+ u8 state;
} POSTPACK HCI_EVENT_SRM_COMPL;
typedef struct hci_event_amp_status_change_t{
- A_UINT8 event_code;
- A_UINT8 param_len;
- A_UINT8 status;
- A_UINT8 amp_status;
+ u8 event_code;
+ u8 param_len;
+ u8 status;
+ u8 amp_status;
} POSTPACK HCI_EVENT_AMP_STATUS_CHANGE;
/*============== Event definitions end =========================== */
typedef struct local_amp_info_resp_t {
- A_UINT8 status;
- A_UINT8 amp_status;
+ u8 status;
+ u8 amp_status;
A_UINT32 total_bw; /* kbps */
A_UINT32 max_guranteed_bw; /* kbps */
A_UINT32 min_latency;
A_UINT32 max_pdu_size;
- A_UINT8 amp_type;
+ u8 amp_type;
A_UINT16 pal_capabilities;
A_UINT16 amp_assoc_len;
A_UINT32 max_flush_timeout; /* in ms */
} POSTPACK LOCAL_AMP_INFO;
typedef struct amp_assoc_cmd_resp_t{
- A_UINT8 status;
- A_UINT8 phy_hdl;
+ u8 status;
+ u8 phy_hdl;
A_UINT16 amp_assoc_len;
- A_UINT8 amp_assoc_frag[AMP_ASSOC_MAX_FRAG_SZ];
+ u8 amp_assoc_frag[AMP_ASSOC_MAX_FRAG_SZ];
}POSTPACK AMP_ASSOC_CMD_RESP;
/* Following are event return parameters.. part of HCI events
*/
typedef struct timeout_read_t {
- A_UINT8 status;
+ u8 status;
A_UINT16 timeout;
}POSTPACK TIMEOUT_INFO;
typedef struct link_supervision_timeout_read_t {
- A_UINT8 status;
+ u8 status;
A_UINT16 hdl;
A_UINT16 timeout;
}POSTPACK LINK_SUPERVISION_TIMEOUT_INFO;
typedef struct status_hdl_t {
- A_UINT8 status;
+ u8 status;
A_UINT16 hdl;
}POSTPACK INFO_STATUS_HDL;
typedef struct write_remote_amp_assoc_t{
- A_UINT8 status;
- A_UINT8 hdl;
+ u8 status;
+ u8 hdl;
}POSTPACK WRITE_REMOTE_AMP_ASSOC_INFO;
typedef struct read_loc_info_t {
- A_UINT8 status;
+ u8 status;
LOCATION_DATA_CFG loc;
}POSTPACK READ_LOC_INFO;
typedef struct read_flow_ctrl_mode_t {
- A_UINT8 status;
- A_UINT8 mode;
+ u8 status;
+ u8 mode;
}POSTPACK READ_FLWCTRL_INFO;
typedef struct read_data_blk_size_t {
- A_UINT8 status;
+ u8 status;
A_UINT16 max_acl_data_pkt_len;
A_UINT16 data_block_len;
A_UINT16 total_num_data_blks;
/* Read Link quality info */
typedef struct link_qual_t {
- A_UINT8 status;
+ u8 status;
A_UINT16 hdl;
- A_UINT8 link_qual;
+ u8 link_qual;
} POSTPACK READ_LINK_QUAL_INFO,
READ_RSSI_INFO;
typedef struct ll_cancel_resp_t {
- A_UINT8 status;
- A_UINT8 phy_link_hdl;
- A_UINT8 tx_flow_spec_id;
+ u8 status;
+ u8 phy_link_hdl;
+ u8 tx_flow_spec_id;
} POSTPACK LL_CANCEL_RESP;
typedef struct read_local_ver_info_t {
- A_UINT8 status;
- A_UINT8 hci_version;
+ u8 status;
+ u8 hci_version;
A_UINT16 hci_revision;
- A_UINT8 pal_version;
+ u8 pal_version;
A_UINT16 manf_name;
A_UINT16 pal_sub_ver;
} POSTPACK READ_LOCAL_VER_INFO;
* A_UINT32 address
* A_UINT32 length, at most BMI_DATASZ_MAX
* Response format:
- * A_UINT8 data[length]
+ * u8 data[length]
*/
#define BMI_WRITE_MEMORY 3
* A_UINT32 command (BMI_WRITE_MEMORY)
* A_UINT32 address
* A_UINT32 length, at most BMI_DATASZ_MAX
- * A_UINT8 data[length]
+ * u8 data[length]
* Response format: none
*/
* A_UINT32 command (BMI_LZ_DATA)
* A_UINT32 length (of compressed data),
* at most BMI_DATASZ_MAX
- * A_UINT8 CompressedData[length]
+ * u8 CompressedData[length]
* Response format: none
* Note: Not supported on all versions of ROM firmware.
*/
PREPACK struct dbglog_buf_s {
struct dbglog_buf_s *next;
- A_UINT8 *buffer;
+ u8 *buffer;
A_UINT32 bufsize;
A_UINT32 length;
A_UINT32 count;
#define HCI_RSVD_EXPECTED_PKT_TYPE_RECV_OFFSET 7
typedef PREPACK struct {
- A_UINT8 _HCIRsvd[8]; /* reserved for HCI packet header (GMBOX) testing */
- A_UINT8 StreamEcho_h; /* stream no. to echo this packet on (filled by host) */
- A_UINT8 StreamEchoSent_t; /* stream no. packet was echoed to (filled by target)
+ u8 _HCIRsvd[8]; /* reserved for HCI packet header (GMBOX) testing */
+ u8 StreamEcho_h; /* stream no. to echo this packet on (filled by host) */
+ u8 StreamEchoSent_t; /* stream no. packet was echoed to (filled by target)
When echoed: StreamEchoSent_t == StreamEcho_h */
- A_UINT8 StreamRecv_t; /* stream no. that target received this packet on (filled by target) */
- A_UINT8 StreamNo_h; /* stream number to send on (filled by host) */
- A_UINT8 Magic_h[4]; /* magic number to filter for this packet on the host*/
- A_UINT8 _rsvd[6]; /* reserved fields that must be set to a "reserved" value
+ u8 StreamRecv_t; /* stream no. that target received this packet on (filled by target) */
+ u8 StreamNo_h; /* stream number to send on (filled by host) */
+ u8 Magic_h[4]; /* magic number to filter for this packet on the host*/
+ u8 _rsvd[6]; /* reserved fields that must be set to a "reserved" value
since this packet maps to a 14-byte ethernet frame we want
to make sure ethertype field is set to something unknown */
- A_UINT8 _pad[2]; /* padding for alignment */
- A_UINT8 TimeStamp[8]; /* timestamp of packet (host or target) */
+ u8 _pad[2]; /* padding for alignment */
+ u8 TimeStamp[8]; /* timestamp of packet (host or target) */
A_UINT32 HostContext_h; /* 4 byte host context, target echos this back */
A_UINT32 SeqNo; /* sequence number (set by host or target) */
A_UINT16 Cmd_h; /* ping command (filled by host) */
A_UINT16 CmdFlags_h; /* optional flags */
- A_UINT8 CmdBuffer_h[8]; /* buffer for command (host -> target) */
- A_UINT8 CmdBuffer_t[8]; /* buffer for command (target -> host) */
+ u8 CmdBuffer_h[8]; /* buffer for command (host -> target) */
+ u8 CmdBuffer_t[8]; /* buffer for command (target -> host) */
A_UINT16 DataLength; /* length of data */
A_UINT16 DataCRC; /* 16 bit CRC of data */
A_UINT16 HeaderCRC; /* header CRC (fields : StreamNo_h to end, minus HeaderCRC) */
typedef PREPACK struct {
A_UINT16 Flags_ConnHandle;
- A_UINT8 Length;
+ u8 Length;
} POSTPACK BT_HCI_SCO_HEADER;
typedef PREPACK struct {
A_UINT16 OpCode;
- A_UINT8 ParamLength;
+ u8 ParamLength;
} POSTPACK BT_HCI_COMMAND_HEADER;
typedef PREPACK struct {
- A_UINT8 EventCode;
- A_UINT8 ParamLength;
+ u8 EventCode;
+ u8 ParamLength;
} POSTPACK BT_HCI_EVENT_HEADER;
/* MBOX host interrupt signal assignments */
#define A_OFFSETOF(type,field) (unsigned long)(&(((type *)NULL)->field))
#define ASSEMBLE_UNALIGNED_UINT16(p,highbyte,lowbyte) \
- (((A_UINT16)(((A_UINT8 *)(p))[(highbyte)])) << 8 | (A_UINT16)(((A_UINT8 *)(p))[(lowbyte)]))
+ (((A_UINT16)(((u8 *)(p))[(highbyte)])) << 8 | (A_UINT16)(((u8 *)(p))[(lowbyte)]))
/* alignment independent macros (little-endian) to fetch UINT16s or UINT8s from a
* structure using only the type and field name.
#define A_SET_UINT16_FIELD(p,type,field,value) \
{ \
- ((A_UINT8 *)(p))[A_OFFSETOF(type,field)] = (A_UINT8)(value); \
- ((A_UINT8 *)(p))[A_OFFSETOF(type,field) + 1] = (A_UINT8)((value) >> 8); \
+ ((u8 *)(p))[A_OFFSETOF(type,field)] = (u8)(value); \
+ ((u8 *)(p))[A_OFFSETOF(type,field) + 1] = (u8)((value) >> 8); \
}
#define A_GET_UINT8_FIELD(p,type,field) \
- ((A_UINT8 *)(p))[A_OFFSETOF(type,field)]
+ ((u8 *)(p))[A_OFFSETOF(type,field)]
#define A_SET_UINT8_FIELD(p,type,field,value) \
- ((A_UINT8 *)(p))[A_OFFSETOF(type,field)] = (value)
+ ((u8 *)(p))[A_OFFSETOF(type,field)] = (value)
/****** DANGER DANGER ***************
*
typedef PREPACK struct _HTC_FRAME_HDR{
/* do not remove or re-arrange these fields, these are minimally required
* to take advantage of 4-byte lookaheads in some hardware implementations */
- A_UINT8 EndpointID;
- A_UINT8 Flags;
+ u8 EndpointID;
+ u8 Flags;
A_UINT16 PayloadLen; /* length of data (including trailer) that follows the header */
/***** end of 4-byte lookahead ****/
- A_UINT8 ControlBytes[2];
+ u8 ControlBytes[2];
/* message payload starts after the header */
A_UINT16 MessageID; /* ID */
A_UINT16 CreditCount; /* number of credits the target can offer */
A_UINT16 CreditSize; /* size of each credit */
- A_UINT8 MaxEndpoints; /* maximum number of endpoints the target has resources for */
- A_UINT8 _Pad1;
+ u8 MaxEndpoints; /* maximum number of endpoints the target has resources for */
+ u8 _Pad1;
} POSTPACK HTC_READY_MSG;
/* extended HTC ready message */
typedef PREPACK struct {
HTC_READY_MSG Version2_0_Info; /* legacy version 2.0 information at the front... */
/* extended information */
- A_UINT8 HTCVersion;
- A_UINT8 MaxMsgsPerHTCBundle;
+ u8 HTCVersion;
+ u8 MaxMsgsPerHTCBundle;
} POSTPACK HTC_READY_EX_MSG;
#define HTC_VERSION_2P0 0x00
#define HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_THREE_FOURTHS 0x2
#define HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_UNITY 0x3
- A_UINT8 ServiceMetaLength; /* length of meta data that follows */
- A_UINT8 _Pad1;
+ u8 ServiceMetaLength; /* length of meta data that follows */
+ u8 _Pad1;
/* service-specific meta data starts after the header */
typedef PREPACK struct {
A_UINT16 MessageID;
A_UINT16 ServiceID; /* service ID that the connection request was made */
- A_UINT8 Status; /* service connection status */
- A_UINT8 EndpointID; /* assigned endpoint ID */
+ u8 Status; /* service connection status */
+ u8 EndpointID; /* assigned endpoint ID */
A_UINT16 MaxMsgSize; /* maximum expected message size on this endpoint */
- A_UINT8 ServiceMetaLength; /* length of meta data that follows */
- A_UINT8 _Pad1;
+ u8 ServiceMetaLength; /* length of meta data that follows */
+ u8 _Pad1;
/* service-specific meta data starts after the header */
typedef PREPACK struct {
A_UINT16 MessageID;
A_UINT32 SetupFlags;
- A_UINT8 MaxMsgsPerBundledRecv;
- A_UINT8 Rsvd[3];
+ u8 MaxMsgsPerBundledRecv;
+ u8 Rsvd[3];
} POSTPACK HTC_SETUP_COMPLETE_EX_MSG;
#define HTC_SETUP_COMPLETE_FLAGS_ENABLE_BUNDLE_RECV (1 << 0)
#define HTC_RECORD_LOOKAHEAD_BUNDLE 3
typedef PREPACK struct {
- A_UINT8 RecordID; /* Record ID */
- A_UINT8 Length; /* Length of record */
+ u8 RecordID; /* Record ID */
+ u8 Length; /* Length of record */
} POSTPACK HTC_RECORD_HDR;
typedef PREPACK struct {
- A_UINT8 EndpointID; /* Endpoint that owns these credits */
- A_UINT8 Credits; /* credits to report since last report */
+ u8 EndpointID; /* Endpoint that owns these credits */
+ u8 Credits; /* credits to report since last report */
} POSTPACK HTC_CREDIT_REPORT;
typedef PREPACK struct {
- A_UINT8 PreValid; /* pre valid guard */
- A_UINT8 LookAhead[4]; /* 4 byte lookahead */
- A_UINT8 PostValid; /* post valid guard */
+ u8 PreValid; /* pre valid guard */
+ u8 LookAhead[4]; /* 4 byte lookahead */
+ u8 PostValid; /* post valid guard */
/* NOTE: the LookAhead array is guarded by a PreValid and Post Valid guard bytes.
* The PreValid bytes must equal the inverse of the PostValid byte */
} POSTPACK HTC_LOOKAHEAD_REPORT;
typedef PREPACK struct {
- A_UINT8 LookAhead[4]; /* 4 byte lookahead */
+ u8 LookAhead[4]; /* 4 byte lookahead */
} POSTPACK HTC_BUNDLED_LOOKAHEAD_REPORT;
#ifndef ATH_TARGET
A_UINT16 regDmnEnum; /* 16 bit reg domain pair */
A_UINT16 regDmn5GHz; /* 5GHz reg domain */
A_UINT16 regDmn2GHz; /* 2GHz reg domain */
- A_UINT8 flags5GHz; /* Requirements flags (AdHoc disallow etc) */
- A_UINT8 flags2GHz; /* Requirements flags (AdHoc disallow etc) */
+ u8 flags5GHz; /* Requirements flags (AdHoc disallow etc) */
+ u8 flags2GHz; /* Requirements flags (AdHoc disallow etc) */
A_UINT32 pscanMask; /* Passive Scan flags which can override unitary domain passive scan
flags. This value is used as a mask on the unitary flags*/
} POSTPACK REG_DMN_PAIR_MAPPING;
typedef PREPACK struct RegDmnFreqBand {
A_UINT16 lowChannel; /* Low channel center in MHz */
A_UINT16 highChannel; /* High Channel center in MHz */
- A_UINT8 power; /* Max power (dBm) for channel range */
- A_UINT8 channelSep; /* Channel separation within the band */
- A_UINT8 useDfs; /* Use DFS in the RegDomain if corresponding bit is set */
- A_UINT8 mode; /* Mode of operation */
+ u8 power; /* Max power (dBm) for channel range */
+ u8 channelSep; /* Channel separation within the band */
+ u8 useDfs; /* Use DFS in the RegDomain if corresponding bit is set */
+ u8 mode; /* Mode of operation */
A_UINT32 usePassScan; /* Use Passive Scan in the RegDomain if corresponding bit is set */
A_UINT32 ht40ChanMask; /* lower 16 bits: indicate which frequencies in the block is HT40 capable
upper 16 bits: what rate (half/quarter) the channel is */
typedef PREPACK struct regDomain {
A_UINT16 regDmnEnum; /* value from EnumRd table */
- A_UINT8 rdCTL;
- A_UINT8 maxAntGain;
- A_UINT8 dfsMask; /* DFS bitmask for 5Ghz tables */
- A_UINT8 flags; /* Requirement flags (AdHoc disallow etc) */
+ u8 rdCTL;
+ u8 maxAntGain;
+ u8 dfsMask; /* DFS bitmask for 5Ghz tables */
+ u8 flags; /* Requirement flags (AdHoc disallow etc) */
A_UINT16 reserved; /* for alignment */
A_UINT32 pscan; /* Bitmask for passive scan */
A_UINT32 chan11a[BMLEN]; /* 64 bit bitmask for channel/band selection */
typedef PREPACK struct wow_config_dset {
- A_UINT8 valid_dset;
- A_UINT8 gpio_enable;
+ u8 valid_dset;
+ u8 gpio_enable;
A_UINT16 gpio_pin;
} POSTPACK WOW_CONFIG_DSET;
* Data Path
*/
typedef PREPACK struct {
- A_UINT8 dstMac[ATH_MAC_LEN];
- A_UINT8 srcMac[ATH_MAC_LEN];
+ u8 dstMac[ATH_MAC_LEN];
+ u8 srcMac[ATH_MAC_LEN];
A_UINT16 typeOrLen;
} POSTPACK ATH_MAC_HDR;
typedef PREPACK struct {
- A_UINT8 dsap;
- A_UINT8 ssap;
- A_UINT8 cntl;
- A_UINT8 orgCode[3];
+ u8 dsap;
+ u8 ssap;
+ u8 cntl;
+ u8 orgCode[3];
A_UINT16 etherType;
} POSTPACK ATH_LLC_SNAP_HDR;
typedef PREPACK struct {
A_INT8 rssi;
- A_UINT8 info; /* usage of 'info' field(8-bit):
+ u8 info; /* usage of 'info' field(8-bit):
* b1:b0 - WMI_MSG_TYPE
* b4:b3:b2 - UP(tid)
* b5 - Used in AP mode. More-data in tx dir, PS in rx.
#endif
typedef PREPACK struct {
- A_UINT8 pktID; /* The packet ID to identify the tx request */
- A_UINT8 ratePolicyID; /* The rate policy to be used for the tx of this frame */
+ u8 pktID; /* The packet ID to identify the tx request */
+ u8 ratePolicyID; /* The rate policy to be used for the tx of this frame */
} POSTPACK WMI_TX_META_V1;
#define WMI_CSUM_DIR_TX (0x1)
#define TX_CSUM_CALC_FILL (0x1)
typedef PREPACK struct {
- A_UINT8 csumStart; /*Offset from start of the WMI header for csum calculation to begin */
- A_UINT8 csumDest; /*Offset from start of WMI header where final csum goes*/
- A_UINT8 csumFlags; /*number of bytes over which csum is calculated*/
+ u8 csumStart; /*Offset from start of the WMI header for csum calculation to begin */
+ u8 csumDest; /*Offset from start of WMI header where final csum goes*/
+ u8 csumFlags; /*number of bytes over which csum is calculated*/
} POSTPACK WMI_TX_META_V2;
#endif
typedef PREPACK struct {
- A_UINT8 status; /* one of WMI_RX_STATUS_... */
- A_UINT8 rix; /* rate index mapped to rate at which this packet was received. */
- A_UINT8 rssi; /* rssi of packet */
- A_UINT8 channel;/* rf channel during packet reception */
+ u8 status; /* one of WMI_RX_STATUS_... */
+ u8 rix; /* rate index mapped to rate at which this packet was received. */
+ u8 rssi; /* rssi of packet */
+ u8 channel;/* rf channel during packet reception */
A_UINT16 flags; /* a combination of WMI_RX_FLAGS_... */
} POSTPACK WMI_RX_META_V1;
#define RX_CSUM_VALID_FLAG (0x1)
typedef PREPACK struct {
A_UINT16 csum;
- A_UINT8 csumFlags;/* bit 0 set -partial csum valid
+ u8 csumFlags;/* bit 0 set -partial csum valid
bit 1 set -test mode */
} POSTPACK WMI_RX_META_V2;
#define DEFAULT_CONNECT_CTRL_FLAGS (CONNECT_CSA_FOLLOW_BSS)
typedef PREPACK struct {
- A_UINT8 networkType;
- A_UINT8 dot11AuthMode;
- A_UINT8 authMode;
- A_UINT8 pairwiseCryptoType;
- A_UINT8 pairwiseCryptoLen;
- A_UINT8 groupCryptoType;
- A_UINT8 groupCryptoLen;
- A_UINT8 ssidLength;
+ u8 networkType;
+ u8 dot11AuthMode;
+ u8 authMode;
+ u8 pairwiseCryptoType;
+ u8 pairwiseCryptoLen;
+ u8 groupCryptoType;
+ u8 groupCryptoLen;
+ u8 ssidLength;
A_UCHAR ssid[WMI_MAX_SSID_LEN];
A_UINT16 channel;
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 bssid[ATH_MAC_LEN];
A_UINT32 ctrl_flags;
} POSTPACK WMI_CONNECT_CMD;
*/
typedef PREPACK struct {
A_UINT16 channel; /* hint */
- A_UINT8 bssid[ATH_MAC_LEN]; /* mandatory if set */
+ u8 bssid[ATH_MAC_LEN]; /* mandatory if set */
} POSTPACK WMI_RECONNECT_CMD;
#define WMI_PMK_LEN 32
typedef PREPACK struct {
- A_UINT8 pmk[WMI_PMK_LEN];
+ u8 pmk[WMI_PMK_LEN];
} POSTPACK WMI_SET_PMK_CMD;
/*
#define KEY_OP_VALID_MASK 0x03
typedef PREPACK struct {
- A_UINT8 keyIndex;
- A_UINT8 keyType;
- A_UINT8 keyUsage; /* KEY_USAGE */
- A_UINT8 keyLength;
- A_UINT8 keyRSC[8]; /* key replay sequence counter */
- A_UINT8 key[WMI_MAX_KEY_LEN];
- A_UINT8 key_op_ctrl; /* Additional Key Control information */
- A_UINT8 key_macaddr[ATH_MAC_LEN];
+ u8 keyIndex;
+ u8 keyType;
+ u8 keyUsage; /* KEY_USAGE */
+ u8 keyLength;
+ u8 keyRSC[8]; /* key replay sequence counter */
+ u8 key[WMI_MAX_KEY_LEN];
+ u8 key_op_ctrl; /* Additional Key Control information */
+ u8 key_macaddr[ATH_MAC_LEN];
} POSTPACK WMI_ADD_CIPHER_KEY_CMD;
/*
* WMI_DELETE_CIPHER_KEY_CMDID
*/
typedef PREPACK struct {
- A_UINT8 keyIndex;
+ u8 keyIndex;
} POSTPACK WMI_DELETE_CIPHER_KEY_CMD;
#define WMI_KRK_LEN 16
* WMI_ADD_KRK_CMDID
*/
typedef PREPACK struct {
- A_UINT8 krk[WMI_KRK_LEN];
+ u8 krk[WMI_KRK_LEN];
} POSTPACK WMI_ADD_KRK_CMD;
/*
} WMI_TKIP_CM_CONTROL;
typedef PREPACK struct {
- A_UINT8 cm_en; /* WMI_TKIP_CM_CONTROL */
+ u8 cm_en; /* WMI_TKIP_CM_CONTROL */
} POSTPACK WMI_SET_TKIP_COUNTERMEASURES_CMD;
/*
} PMKID_ENABLE_FLG;
typedef PREPACK struct {
- A_UINT8 bssid[ATH_MAC_LEN];
- A_UINT8 enable; /* PMKID_ENABLE_FLG */
- A_UINT8 pmkid[WMI_PMKID_LEN];
+ u8 bssid[ATH_MAC_LEN];
+ u8 enable; /* PMKID_ENABLE_FLG */
+ u8 pmkid[WMI_PMKID_LEN];
} POSTPACK WMI_SET_PMKID_CMD;
/*
u32 isLegacy; /* For Legacy Cisco AP compatibility */
A_UINT32 homeDwellTime; /* Maximum duration in the home channel(milliseconds) */
A_UINT32 forceScanInterval; /* Time interval between scans (milliseconds)*/
- A_UINT8 scanType; /* WMI_SCAN_TYPE */
- A_UINT8 numChannels; /* how many channels follow */
+ u8 scanType; /* WMI_SCAN_TYPE */
+ u8 numChannels; /* how many channels follow */
A_UINT16 channelList[1]; /* channels in Mhz */
} POSTPACK WMI_START_SCAN_CMD;
A_UINT16 bg_period; /* seconds */
A_UINT16 maxact_chdwell_time; /* msec */
A_UINT16 pas_chdwell_time; /* msec */
- A_UINT8 shortScanRatio; /* how many shorts scan for one long */
- A_UINT8 scanCtrlFlags;
+ u8 shortScanRatio; /* how many shorts scan for one long */
+ u8 scanCtrlFlags;
A_UINT16 minact_chdwell_time; /* msec */
A_UINT16 maxact_scan_per_ssid; /* max active scans per ssid */
A_UINT32 max_dfsch_act_time; /* msecs */
} WMI_BSS_FILTER;
typedef PREPACK struct {
- A_UINT8 bssFilter; /* see WMI_BSS_FILTER */
- A_UINT8 reserved1; /* For alignment */
+ u8 bssFilter; /* see WMI_BSS_FILTER */
+ u8 reserved1; /* For alignment */
A_UINT16 reserved2; /* For alignment */
A_UINT32 ieMask;
} POSTPACK WMI_BSS_FILTER_CMD;
} WMI_SSID_FLAG;
typedef PREPACK struct {
- A_UINT8 entryIndex; /* 0 to MAX_PROBED_SSID_INDEX */
- A_UINT8 flag; /* WMI_SSID_FLG */
- A_UINT8 ssidLength;
- A_UINT8 ssid[32];
+ u8 entryIndex; /* 0 to MAX_PROBED_SSID_INDEX */
+ u8 flag; /* WMI_SSID_FLG */
+ u8 ssidLength;
+ u8 ssid[32];
} POSTPACK WMI_PROBED_SSID_CMD;
/*
} WMI_POWER_MODE;
typedef PREPACK struct {
- A_UINT8 powerMode; /* WMI_POWER_MODE */
+ u8 powerMode; /* WMI_POWER_MODE */
} POSTPACK WMI_POWER_MODE_CMD;
typedef PREPACK struct {
} POSTPACK WMI_SET_PARAMS_CMD;
typedef PREPACK struct {
- A_UINT8 multicast_mac[ATH_MAC_LEN]; /* WMI_SET_MCAST_FILTER */
+ u8 multicast_mac[ATH_MAC_LEN]; /* WMI_SET_MCAST_FILTER */
} POSTPACK WMI_SET_MCAST_FILTER_CMD;
typedef PREPACK struct {
- A_UINT8 enable; /* WMI_MCAST_FILTER */
+ u8 enable; /* WMI_MCAST_FILTER */
} POSTPACK WMI_MCAST_FILTER_CMD;
/*
} WMI_ADHOC_PS_TYPE;
typedef PREPACK struct {
- A_UINT8 power_saving;
- A_UINT8 ttl; /* number of beacon periods */
+ u8 power_saving;
+ u8 ttl; /* number of beacon periods */
A_UINT16 atim_windows; /* msec */
A_UINT16 timeout_value; /* msec */
} POSTPACK WMI_IBSS_PM_CAPS_CMD;
typedef PREPACK struct {
A_UINT32 idle_time; /* in msec */
A_UINT32 ps_period; /* in usec */
- A_UINT8 sleep_period; /* in ps periods */
- A_UINT8 psType;
+ u8 sleep_period; /* in ps periods */
+ u8 psType;
} POSTPACK WMI_AP_PS_CMD;
/*
} APSD_SP_LEN_TYPE;
typedef PREPACK struct {
- A_UINT8 maxSPLen;
+ u8 maxSPLen;
} POSTPACK WMI_SET_MAX_SP_LEN_CMD;
/*
* WMI_SET_DISC_TIMEOUT_CMDID
*/
typedef PREPACK struct {
- A_UINT8 disconnectTimeout; /* seconds */
+ u8 disconnectTimeout; /* seconds */
} POSTPACK WMI_DISC_TIMEOUT_CMD;
typedef enum {
* WMI_SYNCHRONIZE_CMDID
*/
typedef PREPACK struct {
- A_UINT8 dataSyncMap;
+ u8 dataSyncMap;
} POSTPACK WMI_SYNC_CMD;
/*
A_UINT32 mediumTime;
A_UINT16 nominalMSDU; /* in octects */
A_UINT16 maxMSDU; /* in octects */
- A_UINT8 trafficClass;
- A_UINT8 trafficDirection; /* DIR_TYPE */
- A_UINT8 rxQueueNum;
- A_UINT8 trafficType; /* TRAFFIC_TYPE */
- A_UINT8 voicePSCapability; /* VOICEPS_CAP_TYPE */
- A_UINT8 tsid;
- A_UINT8 userPriority; /* 802.1D user priority */
- A_UINT8 nominalPHY; /* nominal phy rate */
+ u8 trafficClass;
+ u8 trafficDirection; /* DIR_TYPE */
+ u8 rxQueueNum;
+ u8 trafficType; /* TRAFFIC_TYPE */
+ u8 voicePSCapability; /* VOICEPS_CAP_TYPE */
+ u8 tsid;
+ u8 userPriority; /* 802.1D user priority */
+ u8 nominalPHY; /* nominal phy rate */
} POSTPACK WMI_CREATE_PSTREAM_CMD;
/*
* WMI_DELETE_PSTREAM_CMDID
*/
typedef PREPACK struct {
- A_UINT8 txQueueNumber;
- A_UINT8 rxQueueNumber;
- A_UINT8 trafficDirection;
- A_UINT8 trafficClass;
- A_UINT8 tsid;
+ u8 txQueueNumber;
+ u8 rxQueueNumber;
+ u8 trafficDirection;
+ u8 trafficClass;
+ u8 tsid;
} POSTPACK WMI_DELETE_PSTREAM_CMD;
/*
#define WMI_MAX_CHANNELS 32
typedef PREPACK struct {
- A_UINT8 reserved1;
- A_UINT8 scanParam; /* set if enable scan */
- A_UINT8 phyMode; /* see WMI_PHY_MODE */
- A_UINT8 numChannels; /* how many channels follow */
+ u8 reserved1;
+ u8 scanParam; /* set if enable scan */
+ u8 phyMode; /* see WMI_PHY_MODE */
+ u8 numChannels; /* how many channels follow */
A_UINT16 channelList[1]; /* channels in Mhz */
} POSTPACK WMI_CHANNEL_PARAMS_CMD;
A_INT16 thresholdBelow4_Val;
A_INT16 thresholdBelow5_Val;
A_INT16 thresholdBelow6_Val; /* highest of bellow */
- A_UINT8 weight; /* "alpha" */
- A_UINT8 reserved[3];
+ u8 weight; /* "alpha" */
+ u8 reserved[3];
} POSTPACK WMI_RSSI_THRESHOLD_PARAMS_CMD;
/*
typedef PREPACK struct WMI_SNR_THRESHOLD_PARAMS{
A_UINT32 pollTime; /* Polling time as a factor of LI */
- A_UINT8 weight; /* "alpha" */
- A_UINT8 thresholdAbove1_Val; /* lowest of uppper*/
- A_UINT8 thresholdAbove2_Val;
- A_UINT8 thresholdAbove3_Val;
- A_UINT8 thresholdAbove4_Val; /* highest of upper */
- A_UINT8 thresholdBelow1_Val; /* lowest of bellow */
- A_UINT8 thresholdBelow2_Val;
- A_UINT8 thresholdBelow3_Val;
- A_UINT8 thresholdBelow4_Val; /* highest of bellow */
- A_UINT8 reserved[3];
+ u8 weight; /* "alpha" */
+ u8 thresholdAbove1_Val; /* lowest of uppper*/
+ u8 thresholdAbove2_Val;
+ u8 thresholdAbove3_Val;
+ u8 thresholdAbove4_Val; /* highest of upper */
+ u8 thresholdBelow1_Val; /* lowest of bellow */
+ u8 thresholdBelow2_Val;
+ u8 thresholdBelow3_Val;
+ u8 thresholdBelow4_Val; /* highest of bellow */
+ u8 reserved[3];
} POSTPACK WMI_SNR_THRESHOLD_PARAMS_CMD;
/*
* WMI_LQ_THRESHOLD_PARAMS_CMDID
*/
typedef PREPACK struct WMI_LQ_THRESHOLD_PARAMS {
- A_UINT8 enable;
- A_UINT8 thresholdAbove1_Val;
- A_UINT8 thresholdAbove2_Val;
- A_UINT8 thresholdAbove3_Val;
- A_UINT8 thresholdAbove4_Val;
- A_UINT8 thresholdBelow1_Val;
- A_UINT8 thresholdBelow2_Val;
- A_UINT8 thresholdBelow3_Val;
- A_UINT8 thresholdBelow4_Val;
- A_UINT8 reserved[3];
+ u8 enable;
+ u8 thresholdAbove1_Val;
+ u8 thresholdAbove2_Val;
+ u8 thresholdAbove3_Val;
+ u8 thresholdAbove4_Val;
+ u8 thresholdBelow1_Val;
+ u8 thresholdBelow2_Val;
+ u8 thresholdBelow3_Val;
+ u8 thresholdBelow4_Val;
+ u8 reserved[3];
} POSTPACK WMI_LQ_THRESHOLD_PARAMS_CMD;
typedef enum {
} WMI_PREAMBLE_POLICY;
typedef PREPACK struct {
- A_UINT8 status;
- A_UINT8 preamblePolicy;
+ u8 status;
+ u8 preamblePolicy;
}POSTPACK WMI_SET_LPREAMBLE_CMD;
typedef PREPACK struct {
* WMI_SET_TX_PWR_CMDID
*/
typedef PREPACK struct {
- A_UINT8 dbM; /* in dbM units */
+ u8 dbM; /* in dbM units */
} POSTPACK WMI_SET_TX_PWR_CMD, WMI_TX_PWR_REPLY;
/*
#define WMI_MAX_ASSOC_INFO_LEN 240
typedef PREPACK struct {
- A_UINT8 ieType;
- A_UINT8 bufferSize;
- A_UINT8 assocInfo[1]; /* up to WMI_MAX_ASSOC_INFO_LEN */
+ u8 ieType;
+ u8 bufferSize;
+ u8 assocInfo[1]; /* up to WMI_MAX_ASSOC_INFO_LEN */
} POSTPACK WMI_SET_ASSOC_INFO_CMD;
#define WMI_MAX_BAD_AP_INDEX 1
typedef PREPACK struct {
- A_UINT8 badApIndex; /* 0 to WMI_MAX_BAD_AP_INDEX */
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 badApIndex; /* 0 to WMI_MAX_BAD_AP_INDEX */
+ u8 bssid[ATH_MAC_LEN];
} POSTPACK WMI_ADD_BAD_AP_CMD;
/*
* WMI_DELETE_BAD_AP_CMDID
*/
typedef PREPACK struct {
- A_UINT8 badApIndex; /* 0 to WMI_MAX_BAD_AP_INDEX */
+ u8 badApIndex; /* 0 to WMI_MAX_BAD_AP_INDEX */
} POSTPACK WMI_DELETE_BAD_AP_CMD;
/*
#define WMI_MAX_AIFSN_ACPARAM 15
typedef PREPACK struct {
A_UINT16 txop; /* in units of 32 usec */
- A_UINT8 eCWmin;
- A_UINT8 eCWmax;
- A_UINT8 aifsn;
- A_UINT8 ac;
+ u8 eCWmin;
+ u8 eCWmax;
+ u8 aifsn;
+ u8 ac;
} POSTPACK WMI_SET_ACCESS_PARAMS_CMD;
} WMI_FRAMETYPE;
typedef PREPACK struct {
- A_UINT8 frameType; /* WMI_FRAMETYPE */
- A_UINT8 trafficClass; /* applies only to DATA_FRAMETYPE */
- A_UINT8 maxRetries;
- A_UINT8 enableNotify;
+ u8 frameType; /* WMI_FRAMETYPE */
+ u8 trafficClass; /* applies only to DATA_FRAMETYPE */
+ u8 maxRetries;
+ u8 enableNotify;
} POSTPACK WMI_SET_RETRY_LIMITS_CMD;
/*
*/
typedef PREPACK struct {
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 bssid[ATH_MAC_LEN];
A_INT8 bias;
} POSTPACK WMI_BSS_BIAS;
typedef PREPACK struct {
- A_UINT8 numBss;
+ u8 numBss;
WMI_BSS_BIAS bssBias[1];
} POSTPACK WMI_BSS_BIAS_INFO;
A_UINT16 lowrssi_scan_period;
A_INT16 lowrssi_scan_threshold;
A_INT16 lowrssi_roam_threshold;
- A_UINT8 roam_rssi_floor;
- A_UINT8 reserved[1]; /* For alignment */
+ u8 roam_rssi_floor;
+ u8 reserved[1]; /* For alignment */
} POSTPACK WMI_LOWRSSI_SCAN_PARAMS;
typedef PREPACK struct {
PREPACK union {
- A_UINT8 bssid[ATH_MAC_LEN]; /* WMI_FORCE_ROAM */
- A_UINT8 roamMode; /* WMI_SET_ROAM_MODE */
+ u8 bssid[ATH_MAC_LEN]; /* WMI_FORCE_ROAM */
+ u8 roamMode; /* WMI_SET_ROAM_MODE */
WMI_BSS_BIAS_INFO bssBiasInfo; /* WMI_SET_HOST_BIAS */
WMI_LOWRSSI_SCAN_PARAMS lrScanParams;
} POSTPACK info;
- A_UINT8 roamCtrlType ;
+ u8 roamCtrlType ;
} POSTPACK WMI_SET_ROAM_CTRL_CMD;
/*
} BT_WLAN_CONN_PRECEDENCE;
typedef PREPACK struct {
- A_UINT8 precedence;
+ u8 precedence;
} POSTPACK WMI_SET_BT_WLAN_CONN_PRECEDENCE;
/*
* WMI_SET_MAX_OFFHOME_DURATION_CMDID
*/
typedef PREPACK struct {
- A_UINT8 max_offhome_duration;
+ u8 max_offhome_duration;
} POSTPACK WMI_SET_MAX_OFFHOME_DURATION_CMD;
typedef PREPACK struct {
A_UINT32 frequency;
- A_UINT8 threshold;
+ u8 threshold;
} POSTPACK WMI_SET_HB_CHALLENGE_RESP_PARAMS_CMD;
/*---------------------- BTCOEX RELATED -------------------------------------*/
/*----------------------COMMON to AR6002 and AR6003 -------------------------*/
} BT_STREAM_STATUS;
typedef PREPACK struct {
- A_UINT8 streamType;
- A_UINT8 status;
+ u8 streamType;
+ u8 status;
} POSTPACK WMI_SET_BT_STATUS_CMD;
typedef enum {
16..23 Low Data Rate Max Cnt
*/
- A_UINT8 stompDutyCyleVal; /* Sco cycles to limit ps-poll queuing
+ u8 stompDutyCyleVal; /* Sco cycles to limit ps-poll queuing
if stomped */
- A_UINT8 stompDutyCyleMaxVal; /*firm ware increases stomp duty cycle
+ u8 stompDutyCyleMaxVal; /*firm ware increases stomp duty cycle
gradually uptill this value on need basis*/
- A_UINT8 psPollLatencyFraction; /* Fraction of idle
+ u8 psPollLatencyFraction; /* Fraction of idle
period, within which
additional ps-polls
can be queued */
- A_UINT8 noSCOSlots; /* Number of SCO Tx/Rx slots.
+ u8 noSCOSlots; /* Number of SCO Tx/Rx slots.
HVx, EV3, 2EV3 = 2 */
- A_UINT8 noIdleSlots; /* Number of Bluetooth idle slots between
+ u8 noIdleSlots; /* Number of Bluetooth idle slots between
consecutive SCO Tx/Rx slots
HVx, EV3 = 4
2EV3 = 10 */
- A_UINT8 scoOptOffRssi;/*RSSI value below which we go to ps poll*/
- A_UINT8 scoOptOnRssi; /*RSSI value above which we reenter opt mode*/
- A_UINT8 scoOptRtsCount;
+ u8 scoOptOffRssi;/*RSSI value below which we go to ps poll*/
+ u8 scoOptOnRssi; /*RSSI value above which we reenter opt mode*/
+ u8 scoOptRtsCount;
} POSTPACK BT_PARAMS_SCO;
#define BT_A2DP_ALLOW_CLOSE_RANGE_OPT (1 << 0)
8..15 Low Data Rate Min Cnt
16..23 Low Data Rate Max Cnt
*/
- A_UINT8 isCoLocatedBtRoleMaster;
- A_UINT8 a2dpOptOffRssi;/*RSSI value below which we go to ps poll*/
- A_UINT8 a2dpOptOnRssi; /*RSSI value above which we reenter opt mode*/
- A_UINT8 a2dpOptRtsCount;
+ u8 isCoLocatedBtRoleMaster;
+ u8 a2dpOptOffRssi;/*RSSI value below which we go to ps poll*/
+ u8 a2dpOptOnRssi; /*RSSI value above which we reenter opt mode*/
+ u8 a2dpOptRtsCount;
}POSTPACK BT_PARAMS_A2DP;
/* During BT ftp/ BT OPP or any another data based acl profile on bluetooth
BT_PARAMS_SCO scoParams;
BT_PARAMS_A2DP a2dpParams;
BT_PARAMS_ACLCOEX aclCoexParams;
- A_UINT8 antType; /* 0 -Disabled (default)
+ u8 antType; /* 0 -Disabled (default)
1 - BT_ANT_TYPE_DUAL
2 - BT_ANT_TYPE_SPLITTER
3 - BT_ANT_TYPE_SWITCH */
- A_UINT8 coLocatedBtDev; /* 0 - BT_COLOCATED_DEV_BTS4020 (default)
+ u8 coLocatedBtDev; /* 0 - BT_COLOCATED_DEV_BTS4020 (default)
1 - BT_COLCATED_DEV_CSR
2 - BT_COLOCATED_DEV_VALKYRIe
*/
} POSTPACK info;
- A_UINT8 paramType ;
+ u8 paramType ;
} POSTPACK WMI_SET_BT_PARAMS_CMD;
/************************ END AR6002 BTCOEX *******************************/
}WMI_BTCOEX_FE_ANT_TYPE;
typedef PREPACK struct {
- A_UINT8 btcoexFeAntType; /* 1 - WMI_BTCOEX_FE_ANT_SINGLE for single antenna front end
+ u8 btcoexFeAntType; /* 1 - WMI_BTCOEX_FE_ANT_SINGLE for single antenna front end
2 - WMI_BTCOEX_FE_ANT_DUAL for dual antenna front end
(for isolations less 35dB, for higher isolation there
is not need to pass this command).
* bluetooth chip type.Based on bluetooth device, different coexistence protocol would be used.
*/
typedef PREPACK struct {
- A_UINT8 btcoexCoLocatedBTdev; /*1 - Qcom BT (3 -wire PTA)
+ u8 btcoexCoLocatedBTdev; /*1 - Qcom BT (3 -wire PTA)
2 - CSR BT (3 wire PTA)
3 - Atheros 3001 BT (3 wire PTA)
4 - STE bluetooth (4-wire ePTA)
typedef PREPACK struct {
A_UINT16 cmd_buf_sz; /* HCI cmd buffer size */
- A_UINT8 buf[1]; /* Absolute HCI cmd */
+ u8 buf[1]; /* Absolute HCI cmd */
} POSTPACK WMI_HCI_CMD;
/*
* WMI_GET_CHANNEL_LIST_CMDID reply
*/
typedef PREPACK struct {
- A_UINT8 reserved1;
- A_UINT8 numChannels; /* number of channels in reply */
+ u8 reserved1;
+ u8 numChannels; /* number of channels in reply */
A_UINT16 channelList[1]; /* channel in Mhz */
} POSTPACK WMI_CHANNEL_LIST_REPLY;
} PSTREAM_REPLY_STATUS;
typedef PREPACK struct {
- A_UINT8 status; /* PSTREAM_REPLY_STATUS */
- A_UINT8 txQueueNumber;
- A_UINT8 rxQueueNumber;
- A_UINT8 trafficClass;
- A_UINT8 trafficDirection; /* DIR_TYPE */
+ u8 status; /* PSTREAM_REPLY_STATUS */
+ u8 txQueueNumber;
+ u8 rxQueueNumber;
+ u8 trafficClass;
+ u8 trafficDirection; /* DIR_TYPE */
} POSTPACK WMI_CRE_PRIORITY_STREAM_REPLY;
typedef PREPACK struct {
- A_UINT8 status; /* PSTREAM_REPLY_STATUS */
- A_UINT8 txQueueNumber;
- A_UINT8 rxQueueNumber;
- A_UINT8 trafficDirection; /* DIR_TYPE */
- A_UINT8 trafficClass;
+ u8 status; /* PSTREAM_REPLY_STATUS */
+ u8 txQueueNumber;
+ u8 rxQueueNumber;
+ u8 trafficDirection; /* DIR_TYPE */
+ u8 trafficClass;
} POSTPACK WMI_DEL_PRIORITY_STREAM_REPLY;
/*
} WMI_PHY_CAPABILITY;
typedef PREPACK struct {
- A_UINT8 macaddr[ATH_MAC_LEN];
- A_UINT8 phyCapability; /* WMI_PHY_CAPABILITY */
+ u8 macaddr[ATH_MAC_LEN];
+ u8 phyCapability; /* WMI_PHY_CAPABILITY */
} POSTPACK WMI_READY_EVENT_1;
typedef PREPACK struct {
A_UINT32 sw_version;
A_UINT32 abi_version;
- A_UINT8 macaddr[ATH_MAC_LEN];
- A_UINT8 phyCapability; /* WMI_PHY_CAPABILITY */
+ u8 macaddr[ATH_MAC_LEN];
+ u8 phyCapability; /* WMI_PHY_CAPABILITY */
} POSTPACK WMI_READY_EVENT_2;
#if defined(ATH_TARGET)
*/
typedef PREPACK struct {
A_UINT16 channel;
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 bssid[ATH_MAC_LEN];
A_UINT16 listenInterval;
A_UINT16 beaconInterval;
A_UINT32 networkType;
- A_UINT8 beaconIeLen;
- A_UINT8 assocReqLen;
- A_UINT8 assocRespLen;
- A_UINT8 assocInfo[1];
+ u8 beaconIeLen;
+ u8 assocReqLen;
+ u8 assocRespLen;
+ u8 assocInfo[1];
} POSTPACK WMI_CONNECT_EVENT;
/*
typedef PREPACK struct {
A_UINT16 protocolReasonStatus; /* reason code, see 802.11 spec. */
- A_UINT8 bssid[ATH_MAC_LEN]; /* set if known */
- A_UINT8 disconnectReason ; /* see WMI_DISCONNECT_REASON */
- A_UINT8 assocRespLen;
- A_UINT8 assocInfo[1];
+ u8 bssid[ATH_MAC_LEN]; /* set if known */
+ u8 disconnectReason ; /* see WMI_DISCONNECT_REASON */
+ u8 assocRespLen;
+ u8 assocInfo[1];
} POSTPACK WMI_DISCONNECT_EVENT;
/*
typedef PREPACK struct {
A_UINT16 channel;
- A_UINT8 frameType; /* see WMI_BI_FTYPE */
- A_UINT8 snr;
+ u8 frameType; /* see WMI_BI_FTYPE */
+ u8 snr;
A_INT16 rssi;
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 bssid[ATH_MAC_LEN];
A_UINT32 ieMask;
} POSTPACK WMI_BSS_INFO_HDR;
*/
typedef PREPACK struct {
A_UINT16 channel;
- A_UINT8 frameType; /* see WMI_BI_FTYPE */
- A_UINT8 snr;
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 frameType; /* see WMI_BI_FTYPE */
+ u8 snr;
+ u8 bssid[ATH_MAC_LEN];
A_UINT16 ieMask;
} POSTPACK WMI_BSS_INFO_HDR2;
typedef PREPACK struct {
A_UINT16 commandId;
- A_UINT8 errorCode;
+ u8 errorCode;
} POSTPACK WMI_CMD_ERROR_EVENT;
/*
} POSTPACK WMI_REG_DOMAIN_EVENT;
typedef PREPACK struct {
- A_UINT8 txQueueNumber;
- A_UINT8 rxQueueNumber;
- A_UINT8 trafficDirection;
- A_UINT8 trafficClass;
+ u8 txQueueNumber;
+ u8 rxQueueNumber;
+ u8 trafficDirection;
+ u8 trafficClass;
} POSTPACK WMI_PSTREAM_TIMEOUT_EVENT;
typedef PREPACK struct {
- A_UINT8 reserve1;
- A_UINT8 reserve2;
- A_UINT8 reserve3;
- A_UINT8 trafficClass;
+ u8 reserve1;
+ u8 reserve2;
+ u8 reserve3;
+ u8 trafficClass;
} POSTPACK WMI_ACM_REJECT_EVENT;
/*
} WMI_BSS_FLAGS;
typedef PREPACK struct {
- A_UINT8 bssid[ATH_MAC_LEN];
- A_UINT8 bssFlags; /* see WMI_BSS_FLAGS */
+ u8 bssid[ATH_MAC_LEN];
+ u8 bssFlags; /* see WMI_BSS_FLAGS */
} POSTPACK WMI_NEIGHBOR_INFO;
typedef PREPACK struct {
* TKIP MIC Error Event
*/
typedef PREPACK struct {
- A_UINT8 keyid;
- A_UINT8 ismcast;
+ u8 keyid;
+ u8 ismcast;
} POSTPACK WMI_TKIP_MICERR_EVENT;
/*
* WMI_SET_ADHOC_BSSID_CMDID
*/
typedef PREPACK struct {
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 bssid[ATH_MAC_LEN];
} POSTPACK WMI_SET_ADHOC_BSSID_CMD;
/*
} OPT_MODE_TYPE;
typedef PREPACK struct {
- A_UINT8 optMode;
+ u8 optMode;
} POSTPACK WMI_SET_OPT_MODE_CMD;
/*
typedef PREPACK struct {
A_UINT16 optIEDataLen;
- A_UINT8 frmType;
- A_UINT8 dstAddr[ATH_MAC_LEN];
- A_UINT8 bssid[ATH_MAC_LEN];
- A_UINT8 reserved; /* For alignment */
- A_UINT8 optIEData[1];
+ u8 frmType;
+ u8 dstAddr[ATH_MAC_LEN];
+ u8 bssid[ATH_MAC_LEN];
+ u8 reserved; /* For alignment */
+ u8 optIEData[1];
} POSTPACK WMI_OPT_TX_FRAME_CMD;
/*
*/
typedef PREPACK struct {
A_UINT16 channel;
- A_UINT8 frameType; /* see WMI_OPT_FTYPE */
+ u8 frameType; /* see WMI_OPT_FTYPE */
A_INT8 snr;
- A_UINT8 srcAddr[ATH_MAC_LEN];
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 srcAddr[ATH_MAC_LEN];
+ u8 bssid[ATH_MAC_LEN];
} POSTPACK WMI_OPT_RX_INFO_HDR;
/*
A_INT16 cs_aveBeacon_rssi;
A_UINT16 cs_roam_count;
A_INT16 cs_rssi;
- A_UINT8 cs_snr;
- A_UINT8 cs_aveBeacon_snr;
- A_UINT8 cs_lastRoam_msec;
+ u8 cs_snr;
+ u8 cs_aveBeacon_snr;
+ u8 cs_lastRoam_msec;
} POSTPACK cserv_stats_t;
typedef PREPACK struct {
typedef PREPACK struct {
A_UINT32 wow_num_pkts_dropped;
A_UINT16 wow_num_events_discarded;
- A_UINT8 wow_num_host_pkt_wakeups;
- A_UINT8 wow_num_host_event_wakeups;
+ u8 wow_num_host_pkt_wakeups;
+ u8 wow_num_host_event_wakeups;
} POSTPACK wlan_wow_stats_t;
typedef PREPACK struct {
typedef PREPACK struct {
A_INT16 rssi;
- A_UINT8 range;
+ u8 range;
}POSTPACK WMI_RSSI_THRESHOLD_EVENT;
/*
}POSTPACK WMI_TARGET_ERROR_REPORT_EVENT;
typedef PREPACK struct {
- A_UINT8 retrys;
+ u8 retrys;
}POSTPACK WMI_TX_RETRY_ERR_EVENT;
typedef enum{
} WMI_SNR_THRESHOLD_VAL;
typedef PREPACK struct {
- A_UINT8 range; /* WMI_SNR_THRESHOLD_VAL */
- A_UINT8 snr;
+ u8 range; /* WMI_SNR_THRESHOLD_VAL */
+ u8 snr;
}POSTPACK WMI_SNR_THRESHOLD_EVENT;
typedef enum{
typedef PREPACK struct {
A_INT32 lq;
- A_UINT8 range; /* WMI_LQ_THRESHOLD_VAL */
+ u8 range; /* WMI_LQ_THRESHOLD_VAL */
}POSTPACK WMI_LQ_THRESHOLD_EVENT;
/*
* WMI_REPORT_ROAM_TBL_EVENTID
typedef PREPACK struct {
A_INT32 roam_util;
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 bssid[ATH_MAC_LEN];
A_INT8 rssi;
A_INT8 rssidt;
A_INT8 last_rssi;
A_INT8 util;
A_INT8 bias;
- A_UINT8 reserved; /* For alignment */
+ u8 reserved; /* For alignment */
} POSTPACK WMI_BSS_ROAM_INFO;
*/
typedef PREPACK struct {
A_UINT16 evt_buf_sz; /* HCI event buffer size */
- A_UINT8 buf[1]; /* HCI event */
+ u8 buf[1]; /* HCI event */
} POSTPACK WMI_HCI_EVENT;
/*
#define WMM_TSPEC_IE_LEN 63
typedef PREPACK struct {
- A_UINT8 ac;
- A_UINT8 cac_indication;
- A_UINT8 statusCode;
- A_UINT8 tspecSuggestion[WMM_TSPEC_IE_LEN];
+ u8 ac;
+ u8 cac_indication;
+ u8 statusCode;
+ u8 tspecSuggestion[WMM_TSPEC_IE_LEN];
}POSTPACK WMI_CAC_EVENT;
/*
} APLIST_VER;
typedef PREPACK struct {
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 bssid[ATH_MAC_LEN];
A_UINT16 channel;
} POSTPACK WMI_AP_INFO_V1;
} POSTPACK WMI_AP_INFO;
typedef PREPACK struct {
- A_UINT8 apListVer;
- A_UINT8 numAP;
+ u8 apListVer;
+ u8 numAP;
WMI_AP_INFO apList[1];
} POSTPACK WMI_APLIST_EVENT;
} POSTPACK WMI_FIX_RATES_CMD, WMI_FIX_RATES_REPLY;
typedef PREPACK struct {
- A_UINT8 bEnableMask;
- A_UINT8 frameType; /*type and subtype*/
+ u8 bEnableMask;
+ u8 frameType; /*type and subtype*/
A_UINT32 frameRateMask; /* see WMI_BIT_RATE */
} POSTPACK WMI_FRAME_RATES_CMD, WMI_FRAME_RATES_REPLY;
} WMI_AUTH_MODE;
typedef PREPACK struct {
- A_UINT8 mode;
+ u8 mode;
} POSTPACK WMI_SET_AUTH_MODE_CMD;
/*
} WMI_REASSOC_MODE;
typedef PREPACK struct {
- A_UINT8 mode;
+ u8 mode;
}POSTPACK WMI_SET_REASSOC_MODE_CMD;
typedef enum {
A_UINT32 no_txrx_time;
A_UINT32 assoc_time;
A_UINT32 allow_txrx_time;
- A_UINT8 disassoc_bssid[ATH_MAC_LEN];
+ u8 disassoc_bssid[ATH_MAC_LEN];
A_INT8 disassoc_bss_rssi;
- A_UINT8 assoc_bssid[ATH_MAC_LEN];
+ u8 assoc_bssid[ATH_MAC_LEN];
A_INT8 assoc_bss_rssi;
} POSTPACK WMI_TARGET_ROAM_TIME;
PREPACK union {
WMI_TARGET_ROAM_TIME roamTime;
} POSTPACK u;
- A_UINT8 roamDataType ;
+ u8 roamDataType ;
} POSTPACK WMI_TARGET_ROAM_DATA;
typedef enum {
} WMI_WMM_STATUS;
typedef PREPACK struct {
- A_UINT8 status;
+ u8 status;
}POSTPACK WMI_SET_WMM_CMD;
typedef PREPACK struct {
- A_UINT8 status;
+ u8 status;
}POSTPACK WMI_SET_QOS_SUPP_CMD;
typedef enum {
} WMI_TXOP_CFG;
typedef PREPACK struct {
- A_UINT8 txopEnable;
+ u8 txopEnable;
}POSTPACK WMI_SET_WMM_TXOP_CMD;
typedef PREPACK struct {
- A_UINT8 keepaliveInterval;
+ u8 keepaliveInterval;
} POSTPACK WMI_SET_KEEPALIVE_CMD;
typedef PREPACK struct {
u32 configured;
- A_UINT8 keepaliveInterval;
+ u8 keepaliveInterval;
} POSTPACK WMI_GET_KEEPALIVE_CMD;
/*
#define WMI_MAX_IE_LEN 255
typedef PREPACK struct {
- A_UINT8 mgmtFrmType; /* one of WMI_MGMT_FRAME_TYPE */
- A_UINT8 ieLen; /* Length of the IE that should be added to the MGMT frame */
- A_UINT8 ieInfo[1];
+ u8 mgmtFrmType; /* one of WMI_MGMT_FRAME_TYPE */
+ u8 ieLen; /* Length of the IE that should be added to the MGMT frame */
+ u8 ieInfo[1];
} POSTPACK WMI_SET_APPIE_CMD;
/*
}WHAL_CMDID;
typedef PREPACK struct {
- A_UINT8 cabTimeOut;
+ u8 cabTimeOut;
} POSTPACK WHAL_SETCABTO_PARAM;
typedef PREPACK struct {
- A_UINT8 whalCmdId;
- A_UINT8 data[1];
+ u8 whalCmdId;
+ u8 data[1];
} POSTPACK WHAL_PARAMCMD;
#define MAC_MAX_FILTERS_PER_LIST 4
typedef PREPACK struct {
- A_UINT8 wow_valid_filter;
- A_UINT8 wow_filter_id;
- A_UINT8 wow_filter_size;
- A_UINT8 wow_filter_offset;
- A_UINT8 wow_filter_mask[WOW_MASK_SIZE];
- A_UINT8 wow_filter_pattern[WOW_PATTERN_SIZE];
+ u8 wow_valid_filter;
+ u8 wow_filter_id;
+ u8 wow_filter_size;
+ u8 wow_filter_offset;
+ u8 wow_filter_mask[WOW_MASK_SIZE];
+ u8 wow_filter_pattern[WOW_PATTERN_SIZE];
} POSTPACK WOW_FILTER;
typedef PREPACK struct {
- A_UINT8 wow_valid_list;
- A_UINT8 wow_list_id;
- A_UINT8 wow_num_filters;
- A_UINT8 wow_total_list_size;
+ u8 wow_valid_list;
+ u8 wow_list_id;
+ u8 wow_num_filters;
+ u8 wow_total_list_size;
WOW_FILTER list[WOW_MAX_FILTERS_PER_LIST];
} POSTPACK WOW_FILTER_LIST;
typedef PREPACK struct {
- A_UINT8 valid_filter;
- A_UINT8 mac_addr[ATH_MAC_LEN];
+ u8 valid_filter;
+ u8 mac_addr[ATH_MAC_LEN];
} POSTPACK MAC_FILTER;
typedef PREPACK struct {
- A_UINT8 total_list_size;
- A_UINT8 enable;
+ u8 total_list_size;
+ u8 enable;
MAC_FILTER list[MAC_MAX_FILTERS_PER_LIST];
} POSTPACK MAC_FILTER_LIST;
} POSTPACK WMI_SET_WOW_MODE_CMD;
typedef PREPACK struct {
- A_UINT8 filter_list_id;
+ u8 filter_list_id;
} POSTPACK WMI_GET_WOW_LIST_CMD;
/*
* WMI_GET_WOW_LIST_CMD reply
*/
typedef PREPACK struct {
- A_UINT8 num_filters; /* number of patterns in reply */
- A_UINT8 this_filter_num; /* this is filter # x of total num_filters */
- A_UINT8 wow_mode;
- A_UINT8 host_mode;
+ u8 num_filters; /* number of patterns in reply */
+ u8 this_filter_num; /* this is filter # x of total num_filters */
+ u8 wow_mode;
+ u8 host_mode;
WOW_FILTER wow_filters[1];
} POSTPACK WMI_GET_WOW_LIST_REPLY;
typedef PREPACK struct {
- A_UINT8 filter_list_id;
- A_UINT8 filter_size;
- A_UINT8 filter_offset;
- A_UINT8 filter[1];
+ u8 filter_list_id;
+ u8 filter_size;
+ u8 filter_offset;
+ u8 filter[1];
} POSTPACK WMI_ADD_WOW_PATTERN_CMD;
typedef PREPACK struct {
} POSTPACK WMI_DEL_WOW_PATTERN_CMD;
typedef PREPACK struct {
- A_UINT8 macaddr[ATH_MAC_LEN];
+ u8 macaddr[ATH_MAC_LEN];
} POSTPACK WMI_SET_MAC_ADDRESS_CMD;
/*
} POSTPACK WMI_SET_AKMP_PARAMS_CMD;
typedef PREPACK struct {
- A_UINT8 pmkid[WMI_PMKID_LEN];
+ u8 pmkid[WMI_PMKID_LEN];
} POSTPACK WMI_PMKID;
/*
*/
typedef PREPACK struct {
A_UINT32 numPMKID;
- A_UINT8 bssidList[ATH_MAC_LEN][1];
+ u8 bssidList[ATH_MAC_LEN][1];
WMI_PMKID pmkidList[1];
} POSTPACK WMI_PMKID_LIST_REPLY;
/* WMI_ADDBA_REQ_EVENTID */
typedef PREPACK struct {
- A_UINT8 tid;
- A_UINT8 win_sz;
+ u8 tid;
+ u8 win_sz;
A_UINT16 st_seq_no;
- A_UINT8 status; /* f/w response for ADDBA Req; OK(0) or failure(!=0) */
+ u8 status; /* f/w response for ADDBA Req; OK(0) or failure(!=0) */
} POSTPACK WMI_ADDBA_REQ_EVENT;
/* WMI_ADDBA_RESP_EVENTID */
typedef PREPACK struct {
- A_UINT8 tid;
- A_UINT8 status; /* OK(0), failure (!=0) */
+ u8 tid;
+ u8 status; /* OK(0), failure (!=0) */
A_UINT16 amsdu_sz; /* Three values: Not supported(0), 3839, 8k */
} POSTPACK WMI_ADDBA_RESP_EVENT;
* Host is notified of this
*/
typedef PREPACK struct {
- A_UINT8 tid;
- A_UINT8 is_peer_initiator;
+ u8 tid;
+ u8 is_peer_initiator;
A_UINT16 reason_code;
} POSTPACK WMI_DELBA_EVENT;
#define WAPI_REKEY_UCAST 1
#define WAPI_REKEY_MCAST 2
typedef PREPACK struct {
- A_UINT8 type;
- A_UINT8 macAddr[ATH_MAC_LEN];
+ u8 type;
+ u8 macAddr[ATH_MAC_LEN];
} POSTPACK WMI_WAPIREKEY_EVENT;
#endif
* on the given tid
*/
typedef PREPACK struct {
- A_UINT8 tid;
+ u8 tid;
} POSTPACK WMI_ADDBA_REQ_CMD;
/* WMI_DELBA_REQ_CMDID
* is_send_initiator indicates if it's or tx or rx side
*/
typedef PREPACK struct {
- A_UINT8 tid;
- A_UINT8 is_sender_initiator;
+ u8 tid;
+ u8 is_sender_initiator;
} POSTPACK WMI_DELBA_REQ_CMD;
#define PEER_FIRST_NODE_JOIN_EVENT 0x10
#define PEER_LAST_NODE_LEAVE_EVENT 0x11
typedef PREPACK struct {
- A_UINT8 eventCode;
- A_UINT8 peerMacAddr[ATH_MAC_LEN];
+ u8 eventCode;
+ u8 peerMacAddr[ATH_MAC_LEN];
} POSTPACK WMI_PEER_NODE_EVENT;
#define IEEE80211_FRAME_TYPE_MGT 0x00
#define TX_COMPLETE_STATUS_TIMEOUT 3
#define TX_COMPLETE_STATUS_OTHER 4
- A_UINT8 status; /* one of TX_COMPLETE_STATUS_... */
- A_UINT8 pktID; /* packet ID to identify parent packet */
- A_UINT8 rateIdx; /* rate index on successful transmission */
- A_UINT8 ackFailures; /* number of ACK failures in tx attempt */
+ u8 status; /* one of TX_COMPLETE_STATUS_... */
+ u8 pktID; /* packet ID to identify parent packet */
+ u8 rateIdx; /* rate index on successful transmission */
+ u8 ackFailures; /* number of ACK failures in tx attempt */
#if 0 /* optional params currently ommitted. */
A_UINT32 queueDelay; // usec delay measured Tx Start time - host delivery time
A_UINT32 mediaDelay; // usec delay measured ACK rx time - host delivery time
} POSTPACK TX_COMPLETE_MSG_V1; /* version 1 of tx complete msg */
typedef PREPACK struct {
- A_UINT8 numMessages; /* number of tx comp msgs following this struct */
- A_UINT8 msgLen; /* length in bytes for each individual msg following this struct */
- A_UINT8 msgType; /* version of tx complete msg data following this struct */
- A_UINT8 reserved; /* individual messages follow this header */
+ u8 numMessages; /* number of tx comp msgs following this struct */
+ u8 msgLen; /* length in bytes for each individual msg following this struct */
+ u8 msgType; /* version of tx complete msg data following this struct */
+ u8 reserved; /* individual messages follow this header */
} POSTPACK WMI_TX_COMPLETE_EVENT;
#define WMI_TXCOMPLETE_VERSION_1 (0x01)
#define HIDDEN_SSID_FALSE 0
#define HIDDEN_SSID_TRUE 1
typedef PREPACK struct {
- A_UINT8 hidden_ssid;
+ u8 hidden_ssid;
} POSTPACK WMI_AP_HIDDEN_SSID_CMD;
/*
#define AP_ACL_DENY_MAC 0x02
#define AP_ACL_RETAIN_LIST_MASK 0x80
typedef PREPACK struct {
- A_UINT8 policy;
+ u8 policy;
} POSTPACK WMI_AP_ACL_POLICY_CMD;
/*
#define ADD_MAC_ADDR 1
#define DEL_MAC_ADDR 2
typedef PREPACK struct {
- A_UINT8 action;
- A_UINT8 index;
- A_UINT8 mac[ATH_MAC_LEN];
- A_UINT8 wildcard;
+ u8 action;
+ u8 index;
+ u8 mac[ATH_MAC_LEN];
+ u8 wildcard;
} POSTPACK WMI_AP_ACL_MAC_CMD;
typedef PREPACK struct {
A_UINT16 index;
- A_UINT8 acl_mac[AP_ACL_SIZE][ATH_MAC_LEN];
- A_UINT8 wildcard[AP_ACL_SIZE];
- A_UINT8 policy;
+ u8 acl_mac[AP_ACL_SIZE][ATH_MAC_LEN];
+ u8 wildcard[AP_ACL_SIZE];
+ u8 policy;
} POSTPACK WMI_AP_ACL;
/*
* Used with WMI_AP_SET_NUM_STA_CMDID
*/
typedef PREPACK struct {
- A_UINT8 num_sta;
+ u8 num_sta;
} POSTPACK WMI_AP_SET_NUM_STA_CMD;
/*
* Used with WMI_AP_SET_MLME_CMDID
*/
typedef PREPACK struct {
- A_UINT8 mac[ATH_MAC_LEN];
+ u8 mac[ATH_MAC_LEN];
A_UINT16 reason; /* 802.11 reason code */
- A_UINT8 cmd; /* operation to perform */
+ u8 cmd; /* operation to perform */
#define WMI_AP_MLME_ASSOC 1 /* associate station */
#define WMI_AP_DISASSOC 2 /* disassociate station */
#define WMI_AP_DEAUTH 3 /* deauthenticate station */
} POSTPACK WMI_AP_SET_COUNTRY_CMD;
typedef PREPACK struct {
- A_UINT8 dtim;
+ u8 dtim;
} POSTPACK WMI_AP_SET_DTIM_CMD;
typedef PREPACK struct {
- A_UINT8 band; /* specifies which band to apply these values */
- A_UINT8 enable; /* allows 11n to be disabled on a per band basis */
- A_UINT8 chan_width_40M_supported;
- A_UINT8 short_GI_20MHz;
- A_UINT8 short_GI_40MHz;
- A_UINT8 intolerance_40MHz;
- A_UINT8 max_ampdu_len_exp;
+ u8 band; /* specifies which band to apply these values */
+ u8 enable; /* allows 11n to be disabled on a per band basis */
+ u8 chan_width_40M_supported;
+ u8 short_GI_20MHz;
+ u8 short_GI_40MHz;
+ u8 intolerance_40MHz;
+ u8 max_ampdu_len_exp;
} POSTPACK WMI_SET_HT_CAP_CMD;
typedef PREPACK struct {
- A_UINT8 sta_chan_width;
+ u8 sta_chan_width;
} POSTPACK WMI_SET_HT_OP_CMD;
typedef PREPACK struct {
typedef PREPACK struct {
A_UINT32 sgiMask;
- A_UINT8 sgiPERThreshold;
+ u8 sgiPERThreshold;
} POSTPACK WMI_SET_TX_SGI_PARAM_CMD;
#define DEFAULT_SGI_MASK 0x08080000
typedef PREPACK struct {
A_UINT32 rateField; /* 1 bit per rate corresponding to index */
- A_UINT8 id;
- A_UINT8 shortTrys;
- A_UINT8 longTrys;
- A_UINT8 reserved; /* padding */
+ u8 id;
+ u8 shortTrys;
+ u8 longTrys;
+ u8 reserved; /* padding */
} POSTPACK WMI_SET_RATE_POLICY_CMD;
typedef PREPACK struct {
- A_UINT8 metaVersion; /* version of meta data for rx packets <0 = default> (0-7 = valid) */
- A_UINT8 dot11Hdr; /* 1 == leave .11 header intact , 0 == replace .11 header with .3 <default> */
- A_UINT8 defragOnHost; /* 1 == defragmentation is performed by host, 0 == performed by target <default> */
- A_UINT8 reserved[1]; /* alignment */
+ u8 metaVersion; /* version of meta data for rx packets <0 = default> (0-7 = valid) */
+ u8 dot11Hdr; /* 1 == leave .11 header intact , 0 == replace .11 header with .3 <default> */
+ u8 defragOnHost; /* 1 == defragmentation is performed by host, 0 == performed by target <default> */
+ u8 reserved[1]; /* alignment */
} POSTPACK WMI_RX_FRAME_FORMAT_CMD;
typedef PREPACK struct {
- A_UINT8 enable; /* 1 == device operates in thin mode , 0 == normal mode <default> */
- A_UINT8 reserved[3];
+ u8 enable; /* 1 == device operates in thin mode , 0 == normal mode <default> */
+ u8 reserved[3];
} POSTPACK WMI_SET_THIN_MODE_CMD;
/* AP mode events */
#define AP_11BG_RATESET2 2
#define DEF_AP_11BG_RATESET AP_11BG_RATESET1
typedef PREPACK struct {
- A_UINT8 rateset;
+ u8 rateset;
} POSTPACK WMI_AP_SET_11BG_RATESET_CMD;
/*
* End of AP mode definitions
* disabled by default but can be enabled using this structure and the
* WMI_THIN_CONFIG_CMDID. */
typedef PREPACK struct {
- A_UINT8 version; /* the versioned type of messages to use or 0 to disable */
- A_UINT8 countThreshold; /* msg count threshold triggering a tx complete message */
+ u8 version; /* the versioned type of messages to use or 0 to disable */
+ u8 countThreshold; /* msg count threshold triggering a tx complete message */
A_UINT16 timeThreshold; /* timeout interval in MSEC triggering a tx complete message */
} POSTPACK WMI_THIN_CONFIG_TXCOMPLETE;
* without notification. Alternately, the MAC Header is forwarded to the host
* with the failed status. */
typedef PREPACK struct {
- A_UINT8 enable; /* 1 == send decrypt errors to the host, 0 == don't */
- A_UINT8 reserved[3]; /* align padding */
+ u8 enable; /* 1 == send decrypt errors to the host, 0 == don't */
+ u8 reserved[3]; /* align padding */
} POSTPACK WMI_THIN_CONFIG_DECRYPT_ERR;
/* WMI_THIN_CONFIG_TX_MAC_RULES -- Used to configure behavior for transmitted
#define WMI_THIN_CFG_FILTER_RULES 0x00000008
A_UINT32 cfgField; /* combination of WMI_THIN_CFG_... describes contents of config command */
A_UINT16 length; /* length in bytes of appended sub-commands */
- A_UINT8 reserved[2]; /* align padding */
+ u8 reserved[2]; /* align padding */
} POSTPACK WMI_THIN_CONFIG_CMD;
/* MIB Access Identifiers tailored for Symbian. */
};
typedef PREPACK struct {
- A_UINT8 addr[ATH_MAC_LEN];
+ u8 addr[ATH_MAC_LEN];
} POSTPACK WMI_THIN_MIB_STA_MAC;
typedef PREPACK struct {
} POSTPACK WMI_THIN_MIB_RX_LIFE_TIME;
typedef PREPACK struct {
- A_UINT8 enable; //1 = on, 0 = off
+ u8 enable; //1 = on, 0 = off
} POSTPACK WMI_THIN_MIB_CTS_TO_SELF;
typedef PREPACK struct {
} POSTPACK WMI_THIN_MIB_RTS_THRESHOLD;
typedef PREPACK struct {
- A_UINT8 type; // type of frame
- A_UINT8 rate; // tx rate to be used (one of WMI_BIT_RATE)
+ u8 type; // type of frame
+ u8 rate; // tx rate to be used (one of WMI_BIT_RATE)
A_UINT16 length; // num bytes following this structure as the template data
} POSTPACK WMI_THIN_MIB_TEMPLATE_FRAME;
#define IE_FILTER_TREATMENT_APPEAR 2
typedef PREPACK struct {
- A_UINT8 ie;
- A_UINT8 treatment;
+ u8 ie;
+ u8 treatment;
} POSTPACK WMI_THIN_MIB_BEACON_FILTER_TABLE;
typedef PREPACK struct {
- A_UINT8 ie;
- A_UINT8 treatment;
- A_UINT8 oui[3];
- A_UINT8 type;
+ u8 ie;
+ u8 treatment;
+ u8 oui[3];
+ u8 type;
A_UINT16 version;
} POSTPACK WMI_THIN_MIB_BEACON_FILTER_TABLE_OUI;
typedef PREPACK struct {
A_UINT16 numElements;
- A_UINT8 entrySize; // sizeof(WMI_THIN_MIB_BEACON_FILTER_TABLE) on host cpu may be 2 may be 4
- A_UINT8 reserved;
+ u8 entrySize; // sizeof(WMI_THIN_MIB_BEACON_FILTER_TABLE) on host cpu may be 2 may be 4
+ u8 reserved;
} POSTPACK WMI_THIN_MIB_BEACON_FILTER_TABLE_HEADER;
typedef PREPACK struct {
A_UINT32 count; /* num beacons between deliveries */
- A_UINT8 enable;
- A_UINT8 reserved[3];
+ u8 enable;
+ u8 reserved[3];
} POSTPACK WMI_THIN_MIB_BEACON_FILTER;
typedef PREPACK struct {
} POSTPACK WMI_THIN_MIB_BEACON_LOST_COUNT;
typedef PREPACK struct {
- A_UINT8 rssi; /* the low threshold which can trigger an event warning */
- A_UINT8 tolerance; /* the range above and below the threshold to prevent event flooding to the host. */
- A_UINT8 count; /* the sample count of consecutive frames necessary to trigger an event. */
- A_UINT8 reserved[1]; /* padding */
+ u8 rssi; /* the low threshold which can trigger an event warning */
+ u8 tolerance; /* the range above and below the threshold to prevent event flooding to the host. */
+ u8 count; /* the sample count of consecutive frames necessary to trigger an event. */
+ u8 reserved[1]; /* padding */
} POSTPACK WMI_THIN_MIB_RSSI_THRESHOLD;
A_UINT32 cap;
A_UINT32 rxRateField;
A_UINT32 beamForming;
- A_UINT8 addr[ATH_MAC_LEN];
- A_UINT8 enable;
- A_UINT8 stbc;
- A_UINT8 maxAMPDU;
- A_UINT8 msduSpacing;
- A_UINT8 mcsFeedback;
- A_UINT8 antennaSelCap;
+ u8 addr[ATH_MAC_LEN];
+ u8 enable;
+ u8 stbc;
+ u8 maxAMPDU;
+ u8 msduSpacing;
+ u8 mcsFeedback;
+ u8 antennaSelCap;
} POSTPACK WMI_THIN_MIB_HT_CAP;
typedef PREPACK struct {
A_UINT32 infoField;
A_UINT32 basicRateField;
- A_UINT8 protection;
- A_UINT8 secondChanneloffset;
- A_UINT8 channelWidth;
- A_UINT8 reserved;
+ u8 protection;
+ u8 secondChanneloffset;
+ u8 channelWidth;
+ u8 reserved;
} POSTPACK WMI_THIN_MIB_HT_OP;
typedef PREPACK struct {
#define SECOND_BEACON_PRIMARY 1
#define SECOND_BEACON_EITHER 2
#define SECOND_BEACON_SECONDARY 3
- A_UINT8 cfg;
- A_UINT8 reserved[3]; /* padding */
+ u8 cfg;
+ u8 reserved[3]; /* padding */
} POSTPACK WMI_THIN_MIB_HT_2ND_BEACON;
typedef PREPACK struct {
- A_UINT8 txTIDField;
- A_UINT8 rxTIDField;
- A_UINT8 reserved[2]; /* padding */
+ u8 txTIDField;
+ u8 rxTIDField;
+ u8 reserved[2]; /* padding */
} POSTPACK WMI_THIN_MIB_HT_BLOCK_ACK;
typedef PREPACK struct {
- A_UINT8 enableLong; // 1 == long preamble, 0 == short preamble
- A_UINT8 reserved[3];
+ u8 enableLong; // 1 == long preamble, 0 == short preamble
+ u8 reserved[3];
} POSTPACK WMI_THIN_MIB_PREAMBLE;
typedef PREPACK struct {
A_UINT16 length; /* the length in bytes of the appended MIB data */
- A_UINT8 mibID; /* the ID of the MIB element being set */
- A_UINT8 reserved; /* align padding */
+ u8 mibID; /* the ID of the MIB element being set */
+ u8 reserved; /* align padding */
} POSTPACK WMI_THIN_SET_MIB_CMD;
typedef PREPACK struct {
- A_UINT8 mibID; /* the ID of the MIB element being set */
- A_UINT8 reserved[3]; /* align padding */
+ u8 mibID; /* the ID of the MIB element being set */
+ u8 reserved[3]; /* align padding */
} POSTPACK WMI_THIN_GET_MIB_CMD;
typedef PREPACK struct {
A_UINT32 beaconIntval; /* TUs */
A_UINT16 atimWindow; /* TUs */
A_UINT16 channel; /* frequency in Mhz */
- A_UINT8 networkType; /* INFRA_NETWORK | ADHOC_NETWORK */
- A_UINT8 ssidLength; /* 0 - 32 */
- A_UINT8 probe; /* != 0 : issue probe req at start */
- A_UINT8 reserved; /* alignment */
+ u8 networkType; /* INFRA_NETWORK | ADHOC_NETWORK */
+ u8 ssidLength; /* 0 - 32 */
+ u8 probe; /* != 0 : issue probe req at start */
+ u8 reserved; /* alignment */
A_UCHAR ssid[WMI_MAX_SSID_LEN];
- A_UINT8 bssid[ATH_MAC_LEN];
+ u8 bssid[ATH_MAC_LEN];
} POSTPACK WMI_THIN_JOIN_CMD;
typedef PREPACK struct {
}WMI_THIN_JOIN_RESULT;
typedef PREPACK struct {
- A_UINT8 result; /* the result of the join cmd. one of WMI_THIN_JOIN_RESULT */
- A_UINT8 reserved[3]; /* alignment */
+ u8 result; /* the result of the join cmd. one of WMI_THIN_JOIN_RESULT */
+ u8 reserved[3]; /* alignment */
} POSTPACK WMI_THIN_JOIN_EVENT;
#ifdef __cplusplus
A_UINT32 targ_reply_fn;
A_UINT32 targ_reply_arg;
A_UINT32 length;
- A_UINT8 buf[1];
+ u8 buf[1];
} POSTPACK WMIX_DSETDATA_REPLY_CMD;
int ar6000_set_htc_params(HIF_DEVICE *hifDevice,
A_UINT32 TargetType,
A_UINT32 MboxIsrYieldValue,
- A_UINT8 HtcControlBuffers);
+ u8 HtcControlBuffers);
int ar6000_prepare_target(HIF_DEVICE *hifDevice,
A_UINT32 TargetType,
void ar6000_copy_cust_data_from_target(HIF_DEVICE *hifDevice, A_UINT32 TargetType);
-A_UINT8 *ar6000_get_cust_data_buffer(A_UINT32 TargetType);
+u8 *ar6000_get_cust_data_buffer(A_UINT32 TargetType);
-int ar6000_setBTState(void *context, A_UINT8 *pInBuf, A_UINT32 InBufSize);
+int ar6000_setBTState(void *context, u8 *pInBuf, A_UINT32 InBufSize);
-int ar6000_setDevicePowerState(void *context, A_UINT8 *pInBuf, A_UINT32 InBufSize);
+int ar6000_setDevicePowerState(void *context, u8 *pInBuf, A_UINT32 InBufSize);
-int ar6000_setWowMode(void *context, A_UINT8 *pInBuf, A_UINT32 InBufSize);
+int ar6000_setWowMode(void *context, u8 *pInBuf, A_UINT32 InBufSize);
-int ar6000_setHostMode(void *context, A_UINT8 *pInBuf, A_UINT32 InBufSize);
+int ar6000_setHostMode(void *context, u8 *pInBuf, A_UINT32 InBufSize);
#ifdef __cplusplus
}
/* Called to send a DataSet Data Reply back to the Target. */
int wmi_dset_data_reply(struct wmi_t *wmip,
A_UINT32 status,
- A_UINT8 *host_buf,
+ u8 *host_buf,
A_UINT32 length,
A_UINT32 targ_buf,
A_UINT32 targ_reply_fn,
typedef struct _HIF_SCATTER_ITEM {
- A_UINT8 *pBuffer; /* CPU accessible address of buffer */
+ u8 *pBuffer; /* CPU accessible address of buffer */
int Length; /* length of transfer to/from this buffer */
void *pCallerContexts[2]; /* space for caller to insert a context associated with this item */
} HIF_SCATTER_ITEM;
int ValidScatterEntries; /* number of valid entries set by caller */
HIF_SCATTER_METHOD ScatterMethod; /* scatter method handled by HIF */
void *HIFPrivate[4]; /* HIF private area */
- A_UINT8 *pScatterBounceBuffer; /* bounce buffer for upper layers to copy to/from */
+ u8 *pScatterBounceBuffer; /* bounce buffer for upper layers to copy to/from */
HIF_SCATTER_ITEM ScatterList[1]; /* start of scatter list */
} HIF_SCATTER_REQ;
typedef struct _HTC_SERVICE_CONNECT_REQ {
HTC_SERVICE_ID ServiceID; /* service ID to connect to */
A_UINT16 ConnectionFlags; /* connection flags, see htc protocol definition */
- A_UINT8 *pMetaData; /* ptr to optional service-specific meta-data */
- A_UINT8 MetaDataLength; /* optional meta data length */
+ u8 *pMetaData; /* ptr to optional service-specific meta-data */
+ u8 MetaDataLength; /* optional meta data length */
HTC_EP_CALLBACKS EpCallbacks; /* endpoint callbacks */
int MaxSendQueueDepth; /* maximum depth of any send queue */
A_UINT32 LocalConnectionFlags; /* HTC flags for the host-side (local) connection */
/* service connection response information */
typedef struct _HTC_SERVICE_CONNECT_RESP {
- A_UINT8 *pMetaData; /* caller supplied buffer to optional meta-data */
- A_UINT8 BufferLength; /* length of caller supplied buffer */
- A_UINT8 ActualLength; /* actual length of meta data */
+ u8 *pMetaData; /* caller supplied buffer to optional meta-data */
+ u8 BufferLength; /* length of caller supplied buffer */
+ u8 ActualLength; /* actual length of meta data */
HTC_ENDPOINT_ID Endpoint; /* endpoint to communicate over */
unsigned int MaxMsgLength; /* max length of all messages over this endpoint */
- A_UINT8 ConnectRespCode; /* connect response code from target */
+ u8 ConnectRespCode; /* connect response code from target */
} HTC_SERVICE_CONNECT_RESP;
/* endpoint distribution structure */
typedef struct _HTC_TX_PACKET_INFO {
HTC_TX_TAG Tag; /* tag used to selective flush packets */
int CreditsUsed; /* number of credits used for this TX packet (HTC internal) */
- A_UINT8 SendFlags; /* send flags (HTC internal) */
+ u8 SendFlags; /* send flags (HTC internal) */
int SeqNo; /* internal seq no for debugging (HTC internal) */
} HTC_TX_PACKET_INFO;
DL_LIST ListLink; /* double link */
void *pPktContext; /* caller's per packet specific context */
- A_UINT8 *pBufferStart; /* the true buffer start , the caller can
+ u8 *pBufferStart; /* the true buffer start , the caller can
store the real buffer start here. In
receive callbacks, the HTC layer sets pBuffer
to the start of the payload past the header. This
* points to the start of the HTC header but when returned
* to the caller points to the start of the payload
*/
- A_UINT8 *pBuffer; /* payload start (RX/TX) */
+ u8 *pBuffer; /* payload start (RX/TX) */
A_UINT32 BufferLength; /* length of buffer */
A_UINT32 ActualLength; /* actual length of payload */
HTC_ENDPOINT_ID Endpoint; /* endpoint that this packet was sent/recv'd from */
struct ieee80211_common_ie {
A_UINT16 ie_chan;
- A_UINT8 *ie_tstamp;
- A_UINT8 *ie_ssid;
- A_UINT8 *ie_rates;
- A_UINT8 *ie_xrates;
- A_UINT8 *ie_country;
- A_UINT8 *ie_wpa;
- A_UINT8 *ie_rsn;
- A_UINT8 *ie_wmm;
- A_UINT8 *ie_ath;
+ u8 *ie_tstamp;
+ u8 *ie_ssid;
+ u8 *ie_rates;
+ u8 *ie_xrates;
+ u8 *ie_country;
+ u8 *ie_wpa;
+ u8 *ie_rsn;
+ u8 *ie_wmm;
+ u8 *ie_ath;
A_UINT16 ie_capInfo;
A_UINT16 ie_beaconInt;
- A_UINT8 *ie_tim;
- A_UINT8 *ie_chswitch;
- A_UINT8 ie_erp;
- A_UINT8 *ie_wsc;
- A_UINT8 *ie_htcap;
- A_UINT8 *ie_htop;
+ u8 *ie_tim;
+ u8 *ie_chswitch;
+ u8 ie_erp;
+ u8 *ie_wsc;
+ u8 *ie_htcap;
+ u8 *ie_htop;
#ifdef WAPI_ENABLE
- A_UINT8 *ie_wapi;
+ u8 *ie_wapi;
#endif
};
typedef struct bss {
- A_UINT8 ni_macaddr[6];
- A_UINT8 ni_snr;
+ u8 ni_macaddr[6];
+ u8 ni_snr;
A_INT16 ni_rssi;
struct bss *ni_list_next;
struct bss *ni_list_prev;
struct bss *ni_hash_next;
struct bss *ni_hash_prev;
struct ieee80211_common_ie ni_cie;
- A_UINT8 *ni_buf;
+ u8 *ni_buf;
A_UINT16 ni_framelen;
struct ieee80211_node_table *ni_table;
A_UINT32 ni_refcnt;
bss_t *wlan_node_alloc(struct ieee80211_node_table *nt, int wh_size);
void wlan_node_free(bss_t *ni);
void wlan_setup_node(struct ieee80211_node_table *nt, bss_t *ni,
- const A_UINT8 *macaddr);
-bss_t *wlan_find_node(struct ieee80211_node_table *nt, const A_UINT8 *macaddr);
+ const u8 *macaddr);
+bss_t *wlan_find_node(struct ieee80211_node_table *nt, const u8 *macaddr);
void wlan_node_reclaim(struct ieee80211_node_table *nt, bss_t *ni);
void wlan_free_allnodes(struct ieee80211_node_table *nt);
void wlan_iterate_nodes(struct ieee80211_node_table *nt, wlan_node_iter_func *f,
void wlan_node_table_reset(struct ieee80211_node_table *nt);
void wlan_node_table_cleanup(struct ieee80211_node_table *nt);
-int wlan_parse_beacon(A_UINT8 *buf, int framelen,
+int wlan_parse_beacon(u8 *buf, int framelen,
struct ieee80211_common_ie *cie);
A_UINT16 wlan_ieee2freq(int chan);
void
wlan_node_return (struct ieee80211_node_table *nt, bss_t *ni);
-bss_t *wlan_node_remove(struct ieee80211_node_table *nt, A_UINT8 *bssid);
+bss_t *wlan_node_remove(struct ieee80211_node_table *nt, u8 *bssid);
bss_t *
wlan_find_matching_Ssidnode (struct ieee80211_node_table *nt, A_UCHAR *pSsid,
void wmi_shutdown(struct wmi_t *wmip);
HTC_ENDPOINT_ID wmi_get_control_ep(struct wmi_t * wmip);
void wmi_set_control_ep(struct wmi_t * wmip, HTC_ENDPOINT_ID eid);
-A_UINT16 wmi_get_mapped_qos_queue(struct wmi_t *, A_UINT8);
+A_UINT16 wmi_get_mapped_qos_queue(struct wmi_t *, u8 );
int wmi_dix_2_dot3(struct wmi_t *wmip, void *osbuf);
-int wmi_data_hdr_add(struct wmi_t *wmip, void *osbuf, A_UINT8 msgType, bool bMoreData, WMI_DATA_HDR_DATA_TYPE data_type,A_UINT8 metaVersion, void *pTxMetaS);
+int wmi_data_hdr_add(struct wmi_t *wmip, void *osbuf, u8 msgType, bool bMoreData, WMI_DATA_HDR_DATA_TYPE data_type,u8 metaVersion, void *pTxMetaS);
int wmi_dot3_2_dix(void *osbuf);
int wmi_dot11_hdr_remove (struct wmi_t *wmip, void *osbuf);
int wmi_data_hdr_remove(struct wmi_t *wmip, void *osbuf);
int wmi_syncpoint(struct wmi_t *wmip);
int wmi_syncpoint_reset(struct wmi_t *wmip);
-A_UINT8 wmi_implicit_create_pstream(struct wmi_t *wmip, void *osbuf, A_UINT32 layer2Priority, bool wmmEnabled);
+u8 wmi_implicit_create_pstream(struct wmi_t *wmip, void *osbuf, A_UINT32 layer2Priority, bool wmmEnabled);
-A_UINT8 wmi_determine_userPriority (A_UINT8 *pkt, A_UINT32 layer2Pri);
+u8 wmi_determine_userPriority (u8 *pkt, A_UINT32 layer2Pri);
int wmi_control_rx(struct wmi_t *wmip, void *osbuf);
void wmi_iterate_nodes(struct wmi_t *wmip, wlan_node_iter_func *f, void *arg);
void wmi_free_allnodes(struct wmi_t *wmip);
-bss_t *wmi_find_node(struct wmi_t *wmip, const A_UINT8 *macaddr);
-void wmi_free_node(struct wmi_t *wmip, const A_UINT8 *macaddr);
+bss_t *wmi_find_node(struct wmi_t *wmip, const u8 *macaddr);
+void wmi_free_node(struct wmi_t *wmip, const u8 *macaddr);
typedef enum {
DOT11_AUTH_MODE dot11AuthMode,
AUTH_MODE authMode,
CRYPTO_TYPE pairwiseCrypto,
- A_UINT8 pairwiseCryptoLen,
+ u8 pairwiseCryptoLen,
CRYPTO_TYPE groupCrypto,
- A_UINT8 groupCryptoLen,
+ u8 groupCryptoLen,
int ssidLength,
A_UCHAR *ssid,
- A_UINT8 *bssid,
+ u8 *bssid,
A_UINT16 channel,
A_UINT32 ctrl_flags);
int wmi_reconnect_cmd(struct wmi_t *wmip,
- A_UINT8 *bssid,
+ u8 *bssid,
A_UINT16 channel);
int wmi_disconnect_cmd(struct wmi_t *wmip);
int wmi_getrev_cmd(struct wmi_t *wmip);
A_UINT16 fg_end_sec, A_UINT16 bg_sec,
A_UINT16 minact_chdw_msec,
A_UINT16 maxact_chdw_msec, A_UINT16 pas_chdw_msec,
- A_UINT8 shScanRatio, A_UINT8 scanCtrlFlags,
+ u8 shScanRatio, u8 scanCtrlFlags,
A_UINT32 max_dfsch_act_time,
A_UINT16 maxact_scan_per_ssid);
-int wmi_bssfilter_cmd(struct wmi_t *wmip, A_UINT8 filter, A_UINT32 ieMask);
-int wmi_probedSsid_cmd(struct wmi_t *wmip, A_UINT8 index, A_UINT8 flag,
- A_UINT8 ssidLength, A_UCHAR *ssid);
+int wmi_bssfilter_cmd(struct wmi_t *wmip, u8 filter, A_UINT32 ieMask);
+int wmi_probedSsid_cmd(struct wmi_t *wmip, u8 index, u8 flag,
+ u8 ssidLength, A_UCHAR *ssid);
int wmi_listeninterval_cmd(struct wmi_t *wmip, A_UINT16 listenInterval, A_UINT16 listenBeacons);
int wmi_bmisstime_cmd(struct wmi_t *wmip, A_UINT16 bmisstime, A_UINT16 bmissbeacons);
-int wmi_associnfo_cmd(struct wmi_t *wmip, A_UINT8 ieType,
- A_UINT8 ieLen, A_UINT8 *ieInfo);
-int wmi_powermode_cmd(struct wmi_t *wmip, A_UINT8 powerMode);
-int wmi_ibsspmcaps_cmd(struct wmi_t *wmip, A_UINT8 pmEnable, A_UINT8 ttl,
+int wmi_associnfo_cmd(struct wmi_t *wmip, u8 ieType,
+ u8 ieLen, u8 *ieInfo);
+int wmi_powermode_cmd(struct wmi_t *wmip, u8 powerMode);
+int wmi_ibsspmcaps_cmd(struct wmi_t *wmip, u8 pmEnable, u8 ttl,
A_UINT16 atim_windows, A_UINT16 timeout_value);
-int wmi_apps_cmd(struct wmi_t *wmip, A_UINT8 psType, A_UINT32 idle_time,
- A_UINT32 ps_period, A_UINT8 sleep_period);
+int wmi_apps_cmd(struct wmi_t *wmip, u8 psType, A_UINT32 idle_time,
+ A_UINT32 ps_period, u8 sleep_period);
int wmi_pmparams_cmd(struct wmi_t *wmip, A_UINT16 idlePeriod,
A_UINT16 psPollNum, A_UINT16 dtimPolicy,
A_UINT16 wakup_tx_policy, A_UINT16 num_tx_to_wakeup,
A_UINT16 ps_fail_event_policy);
-int wmi_disctimeout_cmd(struct wmi_t *wmip, A_UINT8 timeout);
-int wmi_sync_cmd(struct wmi_t *wmip, A_UINT8 syncNumber);
+int wmi_disctimeout_cmd(struct wmi_t *wmip, u8 timeout);
+int wmi_sync_cmd(struct wmi_t *wmip, u8 syncNumber);
int wmi_create_pstream_cmd(struct wmi_t *wmip, WMI_CREATE_PSTREAM_CMD *pstream);
-int wmi_delete_pstream_cmd(struct wmi_t *wmip, A_UINT8 trafficClass, A_UINT8 streamID);
-int wmi_set_framerate_cmd(struct wmi_t *wmip, A_UINT8 bEnable, A_UINT8 type, A_UINT8 subType, A_UINT16 rateMask);
+int wmi_delete_pstream_cmd(struct wmi_t *wmip, u8 trafficClass, u8 streamID);
+int wmi_set_framerate_cmd(struct wmi_t *wmip, u8 bEnable, u8 type, u8 subType, A_UINT16 rateMask);
int wmi_set_bitrate_cmd(struct wmi_t *wmip, A_INT32 dataRate, A_INT32 mgmtRate, A_INT32 ctlRate);
int wmi_get_bitrate_cmd(struct wmi_t *wmip);
A_INT8 wmi_validate_bitrate(struct wmi_t *wmip, A_INT32 rate, A_INT8 *rate_idx);
int wmi_get_regDomain_cmd(struct wmi_t *wmip);
int wmi_get_channelList_cmd(struct wmi_t *wmip);
-int wmi_set_channelParams_cmd(struct wmi_t *wmip, A_UINT8 scanParam,
+int wmi_set_channelParams_cmd(struct wmi_t *wmip, u8 scanParam,
WMI_PHY_MODE mode, A_INT8 numChan,
A_UINT16 *channelList);
int wmi_set_lq_threshold_params(struct wmi_t *wmip,
WMI_LQ_THRESHOLD_PARAMS_CMD *lqCmd);
int wmi_set_rts_cmd(struct wmi_t *wmip, A_UINT16 threshold);
-int wmi_set_lpreamble_cmd(struct wmi_t *wmip, A_UINT8 status, A_UINT8 preamblePolicy);
+int wmi_set_lpreamble_cmd(struct wmi_t *wmip, u8 status, u8 preamblePolicy);
int wmi_set_error_report_bitmask(struct wmi_t *wmip, A_UINT32 bitmask);
int wmi_get_stats_cmd(struct wmi_t *wmip);
-int wmi_addKey_cmd(struct wmi_t *wmip, A_UINT8 keyIndex,
- CRYPTO_TYPE keyType, A_UINT8 keyUsage,
- A_UINT8 keyLength,A_UINT8 *keyRSC,
- A_UINT8 *keyMaterial, A_UINT8 key_op_ctrl, A_UINT8 *mac,
+int wmi_addKey_cmd(struct wmi_t *wmip, u8 keyIndex,
+ CRYPTO_TYPE keyType, u8 keyUsage,
+ u8 keyLength,u8 *keyRSC,
+ u8 *keyMaterial, u8 key_op_ctrl, u8 *mac,
WMI_SYNC_FLAG sync_flag);
-int wmi_add_krk_cmd(struct wmi_t *wmip, A_UINT8 *krk);
+int wmi_add_krk_cmd(struct wmi_t *wmip, u8 *krk);
int wmi_delete_krk_cmd(struct wmi_t *wmip);
-int wmi_deleteKey_cmd(struct wmi_t *wmip, A_UINT8 keyIndex);
+int wmi_deleteKey_cmd(struct wmi_t *wmip, u8 keyIndex);
int wmi_set_akmp_params_cmd(struct wmi_t *wmip,
WMI_SET_AKMP_PARAMS_CMD *akmpParams);
int wmi_get_pmkid_list_cmd(struct wmi_t *wmip);
int wmi_set_pmkid_list_cmd(struct wmi_t *wmip,
WMI_SET_PMKID_LIST_CMD *pmkInfo);
int wmi_abort_scan_cmd(struct wmi_t *wmip);
-int wmi_set_txPwr_cmd(struct wmi_t *wmip, A_UINT8 dbM);
+int wmi_set_txPwr_cmd(struct wmi_t *wmip, u8 dbM);
int wmi_get_txPwr_cmd(struct wmi_t *wmip);
-int wmi_addBadAp_cmd(struct wmi_t *wmip, A_UINT8 apIndex, A_UINT8 *bssid);
-int wmi_deleteBadAp_cmd(struct wmi_t *wmip, A_UINT8 apIndex);
+int wmi_addBadAp_cmd(struct wmi_t *wmip, u8 apIndex, u8 *bssid);
+int wmi_deleteBadAp_cmd(struct wmi_t *wmip, u8 apIndex);
int wmi_set_tkip_countermeasures_cmd(struct wmi_t *wmip, bool en);
-int wmi_setPmkid_cmd(struct wmi_t *wmip, A_UINT8 *bssid, A_UINT8 *pmkId,
+int wmi_setPmkid_cmd(struct wmi_t *wmip, u8 *bssid, u8 *pmkId,
bool set);
-int wmi_set_access_params_cmd(struct wmi_t *wmip, A_UINT8 ac, A_UINT16 txop,
- A_UINT8 eCWmin, A_UINT8 eCWmax,
- A_UINT8 aifsn);
-int wmi_set_retry_limits_cmd(struct wmi_t *wmip, A_UINT8 frameType,
- A_UINT8 trafficClass, A_UINT8 maxRetries,
- A_UINT8 enableNotify);
+int wmi_set_access_params_cmd(struct wmi_t *wmip, u8 ac, A_UINT16 txop,
+ u8 eCWmin, u8 eCWmax,
+ u8 aifsn);
+int wmi_set_retry_limits_cmd(struct wmi_t *wmip, u8 frameType,
+ u8 trafficClass, u8 maxRetries,
+ u8 enableNotify);
-void wmi_get_current_bssid(struct wmi_t *wmip, A_UINT8 *bssid);
+void wmi_get_current_bssid(struct wmi_t *wmip, u8 *bssid);
int wmi_get_roam_tbl_cmd(struct wmi_t *wmip);
-int wmi_get_roam_data_cmd(struct wmi_t *wmip, A_UINT8 roamDataType);
+int wmi_get_roam_data_cmd(struct wmi_t *wmip, u8 roamDataType);
int wmi_set_roam_ctrl_cmd(struct wmi_t *wmip, WMI_SET_ROAM_CTRL_CMD *p,
- A_UINT8 size);
+ u8 size);
int wmi_set_powersave_timers_cmd(struct wmi_t *wmip,
WMI_POWERSAVE_TIMERS_POLICY_CMD *pCmd,
- A_UINT8 size);
+ u8 size);
-int wmi_set_opt_mode_cmd(struct wmi_t *wmip, A_UINT8 optMode);
+int wmi_set_opt_mode_cmd(struct wmi_t *wmip, u8 optMode);
int wmi_opt_tx_frame_cmd(struct wmi_t *wmip,
- A_UINT8 frmType,
- A_UINT8 *dstMacAddr,
- A_UINT8 *bssid,
+ u8 frmType,
+ u8 *dstMacAddr,
+ u8 *bssid,
A_UINT16 optIEDataLen,
- A_UINT8 *optIEData);
+ u8 *optIEData);
int wmi_set_adhoc_bconIntvl_cmd(struct wmi_t *wmip, A_UINT16 intvl);
int wmi_set_voice_pkt_size_cmd(struct wmi_t *wmip, A_UINT16 voicePktSize);
-int wmi_set_max_sp_len_cmd(struct wmi_t *wmip, A_UINT8 maxSpLen);
-A_UINT8 convert_userPriority_to_trafficClass(A_UINT8 userPriority);
-A_UINT8 wmi_get_power_mode_cmd(struct wmi_t *wmip);
+int wmi_set_max_sp_len_cmd(struct wmi_t *wmip, u8 maxSpLen);
+u8 convert_userPriority_to_trafficClass(u8 userPriority);
+u8 wmi_get_power_mode_cmd(struct wmi_t *wmip);
int wmi_verify_tspec_params(WMI_CREATE_PSTREAM_CMD *pCmd, int tspecCompliance);
#ifdef CONFIG_HOST_TCMD_SUPPORT
-int wmi_test_cmd(struct wmi_t *wmip, A_UINT8 *buf, A_UINT32 len);
+int wmi_test_cmd(struct wmi_t *wmip, u8 *buf, A_UINT32 len);
#endif
-int wmi_set_bt_status_cmd(struct wmi_t *wmip, A_UINT8 streamType, A_UINT8 status);
+int wmi_set_bt_status_cmd(struct wmi_t *wmip, u8 streamType, u8 status);
int wmi_set_bt_params_cmd(struct wmi_t *wmip, WMI_SET_BT_PARAMS_CMD* cmd);
int wmi_set_btcoex_fe_ant_cmd(struct wmi_t *wmip, WMI_SET_BTCOEX_FE_ANT_CMD * cmd);
int wmi_get_btcoex_stats_cmd(struct wmi_t * wmip);
-int wmi_SGI_cmd(struct wmi_t *wmip, A_UINT32 sgiMask, A_UINT8 sgiPERThreshold);
+int wmi_SGI_cmd(struct wmi_t *wmip, A_UINT32 sgiMask, u8 sgiPERThreshold);
/*
* This function is used to configure the fix rates mask to the target.
int wmi_set_fixrates_cmd(struct wmi_t *wmip, A_UINT32 fixRatesMask);
int wmi_get_ratemask_cmd(struct wmi_t *wmip);
-int wmi_set_authmode_cmd(struct wmi_t *wmip, A_UINT8 mode);
+int wmi_set_authmode_cmd(struct wmi_t *wmip, u8 mode);
-int wmi_set_reassocmode_cmd(struct wmi_t *wmip, A_UINT8 mode);
+int wmi_set_reassocmode_cmd(struct wmi_t *wmip, u8 mode);
-int wmi_set_qos_supp_cmd(struct wmi_t *wmip,A_UINT8 status);
+int wmi_set_qos_supp_cmd(struct wmi_t *wmip,u8 status);
int wmi_set_wmm_cmd(struct wmi_t *wmip, WMI_WMM_STATUS status);
int wmi_set_wmm_txop(struct wmi_t *wmip, WMI_TXOP_CFG txEnable);
int wmi_set_country(struct wmi_t *wmip, A_UCHAR *countryCode);
int wmi_get_keepalive_configured(struct wmi_t *wmip);
-A_UINT8 wmi_get_keepalive_cmd(struct wmi_t *wmip);
-int wmi_set_keepalive_cmd(struct wmi_t *wmip, A_UINT8 keepaliveInterval);
+u8 wmi_get_keepalive_cmd(struct wmi_t *wmip);
+int wmi_set_keepalive_cmd(struct wmi_t *wmip, u8 keepaliveInterval);
-int wmi_set_appie_cmd(struct wmi_t *wmip, A_UINT8 mgmtFrmType,
- A_UINT8 ieLen,A_UINT8 *ieInfo);
+int wmi_set_appie_cmd(struct wmi_t *wmip, u8 mgmtFrmType,
+ u8 ieLen,u8 *ieInfo);
-int wmi_set_halparam_cmd(struct wmi_t *wmip, A_UINT8 *cmd, A_UINT16 dataLen);
+int wmi_set_halparam_cmd(struct wmi_t *wmip, u8 *cmd, A_UINT16 dataLen);
A_INT32 wmi_get_rate(A_INT8 rateindex);
int wmi_set_wow_mode_cmd(struct wmi_t *wmip, WMI_SET_WOW_MODE_CMD *cmd);
int wmi_get_wow_list_cmd(struct wmi_t *wmip, WMI_GET_WOW_LIST_CMD *cmd);
int wmi_add_wow_pattern_cmd(struct wmi_t *wmip,
- WMI_ADD_WOW_PATTERN_CMD *cmd, A_UINT8* pattern, A_UINT8* mask, A_UINT8 pattern_size);
+ WMI_ADD_WOW_PATTERN_CMD *cmd, u8 *pattern, u8 *mask, u8 pattern_size);
int wmi_del_wow_pattern_cmd(struct wmi_t *wmip,
WMI_DEL_WOW_PATTERN_CMD *cmd);
int wmi_set_wsc_status_cmd(struct wmi_t *wmip, A_UINT32 status);
wmi_set_params_cmd(struct wmi_t *wmip, A_UINT32 opcode, A_UINT32 length, char *buffer);
int
-wmi_set_mcast_filter_cmd(struct wmi_t *wmip, A_UINT8 dot1, A_UINT8 dot2, A_UINT8 dot3, A_UINT8 dot4);
+wmi_set_mcast_filter_cmd(struct wmi_t *wmip, u8 dot1, u8 dot2, u8 dot3, u8 dot4);
int
-wmi_del_mcast_filter_cmd(struct wmi_t *wmip, A_UINT8 dot1, A_UINT8 dot2, A_UINT8 dot3, A_UINT8 dot4);
+wmi_del_mcast_filter_cmd(struct wmi_t *wmip, u8 dot1, u8 dot2, u8 dot3, u8 dot4);
int
-wmi_mcast_filter_cmd(struct wmi_t *wmip, A_UINT8 enable);
+wmi_mcast_filter_cmd(struct wmi_t *wmip, u8 enable);
bss_t *
wmi_find_Ssidnode (struct wmi_t *wmip, A_UCHAR *pSsid,
int
wmi_set_target_event_report_cmd(struct wmi_t *wmip, WMI_SET_TARGET_EVENT_REPORT_CMD* cmd);
-bss_t *wmi_rm_current_bss (struct wmi_t *wmip, A_UINT8 *id);
-int wmi_add_current_bss (struct wmi_t *wmip, A_UINT8 *id, bss_t *bss);
+bss_t *wmi_rm_current_bss (struct wmi_t *wmip, u8 *id);
+int wmi_add_current_bss (struct wmi_t *wmip, u8 *id, bss_t *bss);
/*
wmi_ap_profile_commit(struct wmi_t *wmip, WMI_CONNECT_CMD *p);
int
-wmi_ap_set_hidden_ssid(struct wmi_t *wmip, A_UINT8 hidden_ssid);
+wmi_ap_set_hidden_ssid(struct wmi_t *wmip, u8 hidden_ssid);
int
-wmi_ap_set_num_sta(struct wmi_t *wmip, A_UINT8 num_sta);
+wmi_ap_set_num_sta(struct wmi_t *wmip, u8 num_sta);
int
-wmi_ap_set_acl_policy(struct wmi_t *wmip, A_UINT8 policy);
+wmi_ap_set_acl_policy(struct wmi_t *wmip, u8 policy);
int
wmi_ap_acl_mac_list(struct wmi_t *wmip, WMI_AP_ACL_MAC_CMD *a);
-A_UINT8
-acl_add_del_mac(WMI_AP_ACL *a, WMI_AP_ACL_MAC_CMD *acl);
+u8 acl_add_del_mac(WMI_AP_ACL *a, WMI_AP_ACL_MAC_CMD *acl);
int
-wmi_ap_set_mlme(struct wmi_t *wmip, A_UINT8 cmd, A_UINT8 *mac, A_UINT16 reason);
+wmi_ap_set_mlme(struct wmi_t *wmip, u8 cmd, u8 *mac, A_UINT16 reason);
int
wmi_set_pvb_cmd(struct wmi_t *wmip, A_UINT16 aid, bool flag);
wmi_ap_bgscan_time(struct wmi_t *wmip, A_UINT32 period, A_UINT32 dwell);
int
-wmi_ap_set_dtim(struct wmi_t *wmip, A_UINT8 dtim);
+wmi_ap_set_dtim(struct wmi_t *wmip, u8 dtim);
int
-wmi_ap_set_rateset(struct wmi_t *wmip, A_UINT8 rateset);
+wmi_ap_set_rateset(struct wmi_t *wmip, u8 rateset);
int
wmi_set_ht_cap_cmd(struct wmi_t *wmip, WMI_SET_HT_CAP_CMD *cmd);
int
-wmi_set_ht_op_cmd(struct wmi_t *wmip, A_UINT8 sta_chan_width);
+wmi_set_ht_op_cmd(struct wmi_t *wmip, u8 sta_chan_width);
int
-wmi_send_hci_cmd(struct wmi_t *wmip, A_UINT8 *buf, A_UINT16 sz);
+wmi_send_hci_cmd(struct wmi_t *wmip, u8 *buf, A_UINT16 sz);
int
wmi_set_tx_select_rates_cmd(struct wmi_t *wmip, A_UINT32 *pMaskArray);
int
-wmi_setup_aggr_cmd(struct wmi_t *wmip, A_UINT8 tid);
+wmi_setup_aggr_cmd(struct wmi_t *wmip, u8 tid);
int
-wmi_delete_aggr_cmd(struct wmi_t *wmip, A_UINT8 tid, bool uplink);
+wmi_delete_aggr_cmd(struct wmi_t *wmip, u8 tid, bool uplink);
int
wmi_allow_aggr_cmd(struct wmi_t *wmip, A_UINT16 tx_tidmask, A_UINT16 rx_tidmask);
int
-wmi_set_rx_frame_format_cmd(struct wmi_t *wmip, A_UINT8 rxMetaVersion, bool rxDot11Hdr, bool defragOnHost);
+wmi_set_rx_frame_format_cmd(struct wmi_t *wmip, u8 rxMetaVersion, bool rxDot11Hdr, bool defragOnHost);
int
wmi_set_thin_mode_cmd(struct wmi_t *wmip, bool bThinMode);
wmi_set_wlan_conn_precedence_cmd(struct wmi_t *wmip, BT_WLAN_CONN_PRECEDENCE precedence);
int
-wmi_set_pmk_cmd(struct wmi_t *wmip, A_UINT8 *pmk);
+wmi_set_pmk_cmd(struct wmi_t *wmip, u8 *pmk);
A_UINT16
wmi_ieee2freq (int chan);
int AthPSInitialize(AR3K_CONFIG_INFO *hdev);
static int SendHCICommand(AR3K_CONFIG_INFO *pConfig,
- A_UINT8 *pBuffer,
+ u8 *pBuffer,
int Length)
{
HTC_PACKET *pPacket = NULL;
}
static int RecvHCIEvent(AR3K_CONFIG_INFO *pConfig,
- A_UINT8 *pBuffer,
+ u8 *pBuffer,
int *pLength)
{
int status = A_OK;
}
int SendHCICommandWaitCommandComplete(AR3K_CONFIG_INFO *pConfig,
- A_UINT8 *pHCICommand,
+ u8 *pHCICommand,
int CmdLength,
- A_UINT8 **ppEventBuffer,
- A_UINT8 **ppBufferToFree)
+ u8 **ppEventBuffer,
+ u8 **ppBufferToFree)
{
int status = A_OK;
- A_UINT8 *pBuffer = NULL;
- A_UINT8 *pTemp;
+ u8 *pBuffer = NULL;
+ u8 *pTemp;
int length;
bool commandComplete = false;
- A_UINT8 opCodeBytes[2];
+ u8 opCodeBytes[2];
do {
length += pConfig->pHCIProps->HeadRoom + pConfig->pHCIProps->TailRoom;
length += pConfig->pHCIProps->IOBlockPad;
- pBuffer = (A_UINT8 *)A_MALLOC(length);
+ pBuffer = (u8 *)A_MALLOC(length);
if (NULL == pBuffer) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("AR3K Config: Failed to allocate bt buffer \n"));
status = A_NO_MEMORY;
static int AR3KConfigureHCIBaud(AR3K_CONFIG_INFO *pConfig)
{
int status = A_OK;
- A_UINT8 hciBaudChangeCommand[] = {0x0c,0xfc,0x2,0,0};
+ u8 hciBaudChangeCommand[] = {0x0c,0xfc,0x2,0,0};
A_UINT16 baudVal;
- A_UINT8 *pEvent = NULL;
- A_UINT8 *pBufferToFree = NULL;
+ u8 *pEvent = NULL;
+ u8 *pBufferToFree = NULL;
do {
if (pConfig->Flags & AR3K_CONFIG_FLAG_SET_AR3K_BAUD) {
baudVal = (A_UINT16)(pConfig->AR3KBaudRate / 100);
- hciBaudChangeCommand[3] = (A_UINT8)baudVal;
- hciBaudChangeCommand[4] = (A_UINT8)(baudVal >> 8);
+ hciBaudChangeCommand[3] = (u8)baudVal;
+ hciBaudChangeCommand[4] = (u8)(baudVal >> 8);
status = SendHCICommandWaitCommandComplete(pConfig,
hciBaudChangeCommand,
int status;
char exitMinBootCmd[] = {0x25,0xFC,0x0c,0x03,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00};
- A_UINT8 *pEvent = NULL;
- A_UINT8 *pBufferToFree = NULL;
+ u8 *pEvent = NULL;
+ u8 *pBufferToFree = NULL;
status = SendHCICommandWaitCommandComplete(pConfig,
exitMinBootCmd,
static int AR3KConfigureSendHCIReset(AR3K_CONFIG_INFO *pConfig)
{
int status = A_OK;
- A_UINT8 hciResetCommand[] = {0x03,0x0c,0x0};
- A_UINT8 *pEvent = NULL;
- A_UINT8 *pBufferToFree = NULL;
+ u8 hciResetCommand[] = {0x03,0x0c,0x0};
+ u8 *pEvent = NULL;
+ u8 *pBufferToFree = NULL;
status = SendHCICommandWaitCommandComplete( pConfig,
hciResetCommand,
/* AR3K vendor specific command for Sleep Enable */
char sleepEnable[] = {0x4,0xFC,0x1,
0x1};
- A_UINT8 *pEvent = NULL;
- A_UINT8 *pBufferToFree = NULL;
+ u8 *pEvent = NULL;
+ u8 *pBufferToFree = NULL;
if (0 != pConfig->IdleTimeout) {
- A_UINT8 idle_lsb = pConfig->IdleTimeout & 0xFF;
- A_UINT8 idle_msb = (pConfig->IdleTimeout & 0xFF00) >> 8;
+ u8 idle_lsb = pConfig->IdleTimeout & 0xFF;
+ u8 idle_msb = (pConfig->IdleTimeout & 0xFF00) >> 8;
hostWakeupConfig[11] = targetWakeupConfig[11] = idle_lsb;
hostWakeupConfig[12] = targetWakeupConfig[12] = idle_msb;
}
}HciCommandListParam;
int SendHCICommandWaitCommandComplete(AR3K_CONFIG_INFO *pConfig,
- A_UINT8 *pHCICommand,
+ u8 *pHCICommand,
int CmdLength,
- A_UINT8 **ppEventBuffer,
- A_UINT8 **ppBufferToFree);
+ u8 **ppEventBuffer,
+ u8 **ppBufferToFree);
A_UINT32 Rom_Version;
A_UINT32 Build_Version;
PSCmdPacket *HciCmdList; /* List storing the commands */
const struct firmware* firmware;
A_UINT32 numCmds;
- A_UINT8 *event;
- A_UINT8 *bufferToFree;
+ u8 *event;
+ u8 *bufferToFree;
struct hci_dev *device;
A_UCHAR *buffer;
A_UINT32 len;
* For HCI SDIO transport, this will be internally defined.
*/
int SendHCICommandWaitCommandComplete(AR3K_CONFIG_INFO *pConfig,
- A_UINT8 *pHCICommand,
+ u8 *pHCICommand,
int CmdLength,
- A_UINT8 **ppEventBuffer,
- A_UINT8 **ppBufferToFree)
+ u8 **ppEventBuffer,
+ u8 **ppBufferToFree)
{
if(CmdLength == 0) {
return A_ERROR;
A_UCHAR bdaddr_cmd[] = { 0x0B, 0xFC, 0x0A, 0x01, 0x01,
0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
- A_UINT8 *event;
- A_UINT8 *bufferToFree = NULL;
+ u8 *event;
+ u8 *bufferToFree = NULL;
int result = A_ERROR;
int inc,outc;
}
int ReadVersionInfo(AR3K_CONFIG_INFO *pConfig)
{
- A_UINT8 hciCommand[] = {0x1E,0xfc,0x00};
- A_UINT8 *event;
- A_UINT8 *bufferToFree = NULL;
+ u8 hciCommand[] = {0x1E,0xfc,0x00};
+ u8 *event;
+ u8 *bufferToFree = NULL;
int result = A_ERROR;
if(A_OK == SendHCICommandWaitCommandComplete(pConfig,hciCommand,sizeof(hciCommand),&event,&bufferToFree)) {
result = ReadPSEvent(event);
}
int getDeviceType(AR3K_CONFIG_INFO *pConfig, A_UINT32 * code)
{
- A_UINT8 hciCommand[] = {0x05,0xfc,0x05,0x00,0x00,0x00,0x00,0x04};
- A_UINT8 *event;
- A_UINT8 *bufferToFree = NULL;
+ u8 hciCommand[] = {0x05,0xfc,0x05,0x00,0x00,0x00,0x00,0x04};
+ u8 *event;
+ u8 *bufferToFree = NULL;
A_UINT32 reg;
int result = A_ERROR;
*code = 0;
- hciCommand[3] = (A_UINT8)(FPGA_REGISTER & 0xFF);
- hciCommand[4] = (A_UINT8)((FPGA_REGISTER >> 8) & 0xFF);
- hciCommand[5] = (A_UINT8)((FPGA_REGISTER >> 16) & 0xFF);
- hciCommand[6] = (A_UINT8)((FPGA_REGISTER >> 24) & 0xFF);
+ hciCommand[3] = (u8)(FPGA_REGISTER & 0xFF);
+ hciCommand[4] = (u8)((FPGA_REGISTER >> 8) & 0xFF);
+ hciCommand[5] = (u8)((FPGA_REGISTER >> 16) & 0xFF);
+ hciCommand[6] = (u8)((FPGA_REGISTER >> 24) & 0xFF);
if(A_OK == SendHCICommandWaitCommandComplete(pConfig,hciCommand,sizeof(hciCommand),&event,&bufferToFree)) {
if(event[4] == 0xFC && event[5] == 0x00){
{
A_UINT32 TagId;
A_UINT32 TagLen;
- A_UINT8 *TagData;
+ u8 *TagData;
} tPsTagEntry, *tpPsTagEntry;
typedef struct tRamPatch
{
A_UINT16 Len;
- A_UINT8 * Data;
+ u8 *Data;
} tRamPatch, *ptRamPatch;
{
char *Buffer;
char *pCharLine;
- A_UINT8 TagCount;
+ u8 TagCount;
A_UINT16 ByteCount;
- A_UINT8 ParseSection=RAM_PS_SECTION;
+ u8 ParseSection=RAM_PS_SECTION;
A_UINT32 pos;
return A_ERROR;
}
PsTagEntry[TagCount].TagLen = ByteCount;
- PsTagEntry[TagCount].TagData = (A_UINT8*)A_MALLOC(ByteCount);
+ PsTagEntry[TagCount].TagData = (u8 *)A_MALLOC(ByteCount);
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" TAG Length %d Tag Index %d \n",PsTagEntry[TagCount].TagLen,TagCount));
stReadStatus.uSection = 3;
stReadStatus.uLineCount = 0;
if((stPS_DataFormat.eDataType == eHex) && stPS_DataFormat.bIsArray == true) {
while(uReadCount > 0) {
PsTagEntry[TagCount].TagData[stReadStatus.uByteCount] =
- (A_UINT8)(hex_to_bin(pCharLine[stReadStatus.uCharCount]) << 4)
- | (A_UINT8)(hex_to_bin(pCharLine[stReadStatus.uCharCount + 1]));
+ (u8)(hex_to_bin(pCharLine[stReadStatus.uCharCount]) << 4)
+ | (u8)(hex_to_bin(pCharLine[stReadStatus.uCharCount + 1]));
PsTagEntry[TagCount].TagData[stReadStatus.uByteCount+1] =
- (A_UINT8)(hex_to_bin(pCharLine[stReadStatus.uCharCount + 3]) << 4)
- | (A_UINT8)(hex_to_bin(pCharLine[stReadStatus.uCharCount + 4]));
+ (u8)(hex_to_bin(pCharLine[stReadStatus.uCharCount + 3]) << 4)
+ | (u8)(hex_to_bin(pCharLine[stReadStatus.uCharCount + 4]));
stReadStatus.uCharCount += 6; // read two bytes, plus a space;
stReadStatus.uByteCount += 2;
return A_ERROR;
}
RamPatch[Patch_Count].Len= MAX_BYTE_LENGTH;
- RamPatch[Patch_Count].Data = (A_UINT8*)A_MALLOC(MAX_BYTE_LENGTH);
+ RamPatch[Patch_Count].Data = (u8 *)A_MALLOC(MAX_BYTE_LENGTH);
Patch_Count ++;
RamPatch[Patch_Count].Len= (ByteCount & 0xFF);
if(ByteCount != 0) {
- RamPatch[Patch_Count].Data = (A_UINT8*)A_MALLOC(ByteCount);
+ RamPatch[Patch_Count].Data = (u8 *)A_MALLOC(ByteCount);
Patch_Count ++;
}
count = 0;
int AthCreateCommandList(PSCmdPacket **HciPacketList, A_UINT32 *numPackets)
{
- A_UINT8 count;
+ u8 count;
A_UINT32 NumcmdEntry = 0;
A_UINT32 Crc = 0;
#define A_UCHAR unsigned char
#define A_UINT32 unsigned long
#define A_UINT16 unsigned short
-#define A_UINT8 unsigned char
+#define u8 unsigned char
#define bool unsigned char
#endif /* A_UINT32 */
#define CPU_DBG_SEL_ADDRESS 0x00000483
#define CPU_DBG_ADDRESS 0x00000484
-static A_UINT8 custDataAR6002[AR6002_CUST_DATA_SIZE];
-static A_UINT8 custDataAR6003[AR6003_CUST_DATA_SIZE];
+static u8 custDataAR6002[AR6002_CUST_DATA_SIZE];
+static u8 custDataAR6003[AR6003_CUST_DATA_SIZE];
/* Compile the 4BYTE version of the window register setup routine,
* This mitigates host interconnect issues with non-4byte aligned bus requests, some
int ar6000_SetAddressWindowRegister(HIF_DEVICE *hifDevice, A_UINT32 RegisterAddr, A_UINT32 Address)
{
int status;
- A_UINT8 addrValue[4];
+ u8 addrValue[4];
A_INT32 i;
/* write bytes 1,2,3 of the register to set the upper address bytes, the LSB is written
for (i = 1; i <= 3; i++) {
/* fill the buffer with the address byte value we want to hit 4 times*/
- addrValue[0] = ((A_UINT8 *)&Address)[i];
+ addrValue[0] = ((u8 *)&Address)[i];
addrValue[1] = addrValue[0];
addrValue[2] = addrValue[0];
addrValue[3] = addrValue[0];
status = HIFReadWrite(hifDevice,
RegisterAddr,
(A_UCHAR *)(&Address),
- sizeof(A_UINT8),
+ sizeof(u8),
HIF_WR_SYNC_BYTE_INC,
NULL);
ar6000_copy_cust_data_from_target(HIF_DEVICE *hifDevice, A_UINT32 TargetType)
{
A_UINT32 eepHeaderAddr;
- A_UINT8 AR6003CustDataShadow[AR6003_CUST_DATA_SIZE+4];
+ u8 AR6003CustDataShadow[AR6003_CUST_DATA_SIZE+4];
A_INT32 i;
if (BMIReadMemory(hifDevice,
}
/* This is the function to call when need to use the cust data */
-A_UINT8 *
-ar6000_get_cust_data_buffer(A_UINT32 TargetType)
+u8 *ar6000_get_cust_data_buffer(A_UINT32 TargetType)
{
if (TargetType == TARGET_TYPE_AR6003)
return custDataAR6003;
int ar6000_set_htc_params(HIF_DEVICE *hifDevice,
A_UINT32 TargetType,
A_UINT32 MboxIsrYieldValue,
- A_UINT8 HtcControlBuffers)
+ u8 HtcControlBuffers)
{
int status;
A_UINT32 blocksizes[HTC_MAILBOX_NUM_MAX];
#define LINUX_HACK_FUDGE_FACTOR 16
#define BDATA_BDADDR_OFFSET 28
-A_UINT8 bcast_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
-A_UINT8 null_mac[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+u8 bcast_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+u8 null_mac[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
#ifdef DEBUG
static struct ar_cookie *ar6000_alloc_cookie(AR_SOFTC_T *ar);
#ifdef USER_KEYS
-static int ar6000_reinstall_keys(AR_SOFTC_T *ar,A_UINT8 key_op_ctrl);
+static int ar6000_reinstall_keys(AR_SOFTC_T *ar,u8 key_op_ctrl);
#endif
#ifdef CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT
send = dbglog_get_debug_fragment(&buffer[sent], length - sent,
MAX_WIRELESS_EVENT_SIZE);
while (send) {
- ar6000_send_event_to_app(ar, WMIX_DBGLOG_EVENTID, (A_UINT8*)&buffer[sent], send);
+ ar6000_send_event_to_app(ar, WMIX_DBGLOG_EVENTID, (u8 *)&buffer[sent], send);
sent += send;
send = dbglog_get_debug_fragment(&buffer[sent], length - sent,
MAX_WIRELESS_EVENT_SIZE);
A_UCHAR *ptr_mac;
switch (ar->arTargetType) {
case TARGET_TYPE_AR6002:
- ptr_mac = (A_UINT8 *)((A_UCHAR *)eeprom_data + AR6002_MAC_ADDRESS_OFFSET);
+ ptr_mac = (u8 *)((A_UCHAR *)eeprom_data + AR6002_MAC_ADDRESS_OFFSET);
break;
case TARGET_TYPE_AR6003:
- ptr_mac = (A_UINT8 *)((A_UCHAR *)eeprom_data + AR6003_MAC_ADDRESS_OFFSET);
+ ptr_mac = (u8 *)((A_UCHAR *)eeprom_data + AR6003_MAC_ADDRESS_OFFSET);
break;
default:
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Invalid Target Type\n"));
errEvent.errorVal = WMI_TARGET_COM_ERR |
WMI_TARGET_FATAL_ERR;
ar6000_send_event_to_app(ar, WMI_ERROR_REPORT_EVENTID,
- (A_UINT8 *)&errEvent,
+ (u8 *)&errEvent,
sizeof(WMI_TARGET_ERROR_REPORT_EVENT));
}
}
errEvent.errorVal = WMI_TARGET_COM_ERR | WMI_TARGET_FATAL_ERR;
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
ar6000_send_event_to_app(ar, WMI_ERROR_REPORT_EVENTID,
- (A_UINT8 *)&errEvent,
+ (u8 *)&errEvent,
sizeof(WMI_TARGET_ERROR_REPORT_EVENT));
return;
}
/* Initialize the AP mode state info */
{
- A_UINT8 ctr;
- A_MEMZERO((A_UINT8 *)ar->sta_list, AP_MAX_NUM_STA * sizeof(sta_t));
+ u8 ctr;
+ A_MEMZERO((u8 *)ar->sta_list, AP_MAX_NUM_STA * sizeof(sta_t));
/* init the Mutexes */
A_MUTEX_INIT(&ar->mcastpsqLock);
}
HTC_ENDPOINT_ID
-ar6000_ac2_endpoint_id ( void * devt, A_UINT8 ac)
+ar6000_ac2_endpoint_id ( void * devt, u8 ac)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *) devt;
return(arAc2EndpointID(ar, ac));
}
-A_UINT8
-ar6000_endpoint_id2_ac(void * devt, HTC_ENDPOINT_ID ep )
+u8 ar6000_endpoint_id2_ac(void * devt, HTC_ENDPOINT_ID ep )
{
AR_SOFTC_T *ar = (AR_SOFTC_T *) devt;
return(arEndpoint2Ac(ar, ep ));
}
void
-ar6000_txPwr_rx(void *devt, A_UINT8 txPwr)
+ar6000_txPwr_rx(void *devt, u8 txPwr)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
wake_up(&arEvent);
}
-A_UINT8
-ar6000_ibss_map_epid(struct sk_buff *skb, struct net_device *dev, A_UINT32 * mapNo)
+u8 ar6000_ibss_map_epid(struct sk_buff *skb, struct net_device *dev, A_UINT32 * mapNo)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
- A_UINT8 *datap;
+ u8 *datap;
ATH_MAC_HDR *macHdr;
A_UINT32 i, eptMap;
{
#define AC_NOT_MAPPED 99
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
- A_UINT8 ac = AC_NOT_MAPPED;
+ u8 ac = AC_NOT_MAPPED;
HTC_ENDPOINT_ID eid = ENDPOINT_UNUSED;
A_UINT32 mapNo = 0;
int len;
struct ar_cookie *cookie;
bool checkAdHocPsMapping = false,bMoreData = false;
HTC_TX_TAG htc_tag = AR6K_DATA_PKT_TAG;
- A_UINT8 dot11Hdr = processDot11Hdr;
+ u8 dot11Hdr = processDot11Hdr;
#ifdef CONFIG_PM
if (ar->arWowState != WLAN_WOW_STATE_NONE) {
A_NETBUF_FREE(skb);
* mcastq
*/
if (IEEE80211_IS_MULTICAST(datap->dstMac)) {
- A_UINT8 ctr=0;
+ u8 ctr=0;
bool qMcast=false;
if (ar->arWmiEnabled) {
#ifdef CONFIG_CHECKSUM_OFFLOAD
- A_UINT8 csumStart=0;
- A_UINT8 csumDest=0;
- A_UINT8 csum=skb->ip_summed;
+ u8 csumStart=0;
+ u8 csumDest=0;
+ u8 csum=skb->ip_summed;
if(csumOffload && (csum==CHECKSUM_PARTIAL)){
csumStart = (skb->head + skb->csum_start - skb_network_header(skb) +
sizeof(ATH_LLC_SNAP_HDR));
}
sta_t *
-ieee80211_find_conn(AR_SOFTC_T *ar, A_UINT8 *node_addr)
+ieee80211_find_conn(AR_SOFTC_T *ar, u8 *node_addr)
{
sta_t *conn = NULL;
- A_UINT8 i, max_conn;
+ u8 i, max_conn;
switch(ar->arNetworkType) {
case AP_NETWORK:
return conn;
}
-sta_t *ieee80211_find_conn_for_aid(AR_SOFTC_T *ar, A_UINT8 aid)
+sta_t *ieee80211_find_conn_for_aid(AR_SOFTC_T *ar, u8 aid)
{
sta_t *conn = NULL;
- A_UINT8 ctr;
+ u8 ctr;
for (ctr = 0; ctr < AP_MAX_NUM_STA; ctr++) {
if (ar->sta_list[ctr].aid == aid) {
AR_SOFTC_T *ar = (AR_SOFTC_T *)Context;
struct sk_buff *skb = (struct sk_buff *)pPacket->pPktContext;
int minHdrLen;
- A_UINT8 containsDot11Hdr = 0;
+ u8 containsDot11Hdr = 0;
int status = pPacket->Status;
HTC_ENDPOINT_ID ept = pPacket->Endpoint;
} else {
WMI_DATA_HDR *dhdr = (WMI_DATA_HDR *)A_NETBUF_DATA(skb);
bool is_amsdu;
- A_UINT8 tid;
+ u8 tid;
bool is_acl_data_frame;
is_acl_data_frame = WMI_DATA_HDR_GET_DATA_TYPE(dhdr) == WMI_DATA_HDR_DATA_TYPE_ACL;
#ifdef CONFIG_PM
A_NETBUF_FREE(skb);
} else {
A_UINT16 seq_no;
- A_UINT8 meta_type;
+ u8 meta_type;
#if 0
/* Access RSSI values here */
/* Get the Power save state of the STA */
if (ar->arNetworkType == AP_NETWORK) {
sta_t *conn = NULL;
- A_UINT8 psState=0,prevPsState;
+ u8 psState=0,prevPsState;
ATH_MAC_HDR *datap=NULL;
A_UINT16 offset;
}
void
-ar6000_ready_event(void *devt, A_UINT8 *datap, A_UINT8 phyCap, A_UINT32 sw_ver, A_UINT32 abi_ver)
+ar6000_ready_event(void *devt, u8 *datap, u8 phyCap, A_UINT32 sw_ver, A_UINT32 abi_ver)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
struct net_device *dev = ar->arNetDev;
}
void
-add_new_sta(AR_SOFTC_T *ar, A_UINT8 *mac, A_UINT16 aid, A_UINT8 *wpaie,
- A_UINT8 ielen, A_UINT8 keymgmt, A_UINT8 ucipher, A_UINT8 auth)
+add_new_sta(AR_SOFTC_T *ar, u8 *mac, A_UINT16 aid, u8 *wpaie,
+ u8 ielen, u8 keymgmt, u8 ucipher, u8 auth)
{
- A_UINT8 free_slot=aid-1;
+ u8 free_slot=aid-1;
A_MEMCPY(ar->sta_list[free_slot].mac, mac, ATH_MAC_LEN);
A_MEMCPY(ar->sta_list[free_slot].wpa_ie, wpaie, ielen);
}
void
-ar6000_connect_event(AR_SOFTC_T *ar, A_UINT16 channel, A_UINT8 *bssid,
+ar6000_connect_event(AR_SOFTC_T *ar, A_UINT16 channel, u8 *bssid,
A_UINT16 listenInterval, A_UINT16 beaconInterval,
- NETWORK_TYPE networkType, A_UINT8 beaconIeLen,
- A_UINT8 assocReqLen, A_UINT8 assocRespLen,
- A_UINT8 *assocInfo)
+ NETWORK_TYPE networkType, u8 beaconIeLen,
+ u8 assocReqLen, u8 assocRespLen,
+ u8 *assocInfo)
{
union iwreq_data wrqu;
int i, beacon_ie_pos, assoc_resp_ie_pos, assoc_req_ie_pos;
static const char *beaconIetag = "BEACONIE=";
char buf[WMI_CONTROL_MSG_MAX_LEN * 2 + strlen(tag1) + 1];
char *pos;
- A_UINT8 key_op_ctrl;
+ u8 key_op_ctrl;
unsigned long flags;
struct ieee80211req_key *ik;
CRYPTO_TYPE keyType = NONE_CRYPT;
goto skip_key;
}
wmi_addKey_cmd(ar->arWmi, ik->ik_keyix, keyType, GROUP_USAGE,
- ik->ik_keylen, (A_UINT8 *)&ik->ik_keyrsc,
+ ik->ik_keylen, (u8 *)&ik->ik_keyrsc,
ik->ik_keydata, KEY_OP_INIT_VAL, ik->ik_macaddr,
SYNC_BOTH_WMIFLAG);
}
void
-sta_cleanup(AR_SOFTC_T *ar, A_UINT8 i)
+sta_cleanup(AR_SOFTC_T *ar, u8 i)
{
struct sk_buff *skb;
}
-A_UINT8
-remove_sta(AR_SOFTC_T *ar, A_UINT8 *mac, A_UINT16 reason)
+u8 remove_sta(AR_SOFTC_T *ar, u8 *mac, A_UINT16 reason)
{
- A_UINT8 i, removed=0;
+ u8 i, removed=0;
if(IS_MAC_NULL(mac)) {
return removed;
}
void
-ar6000_disconnect_event(AR_SOFTC_T *ar, A_UINT8 reason, A_UINT8 *bssid,
- A_UINT8 assocRespLen, A_UINT8 *assocInfo, A_UINT16 protocolReasonStatus)
+ar6000_disconnect_event(AR_SOFTC_T *ar, u8 reason, u8 *bssid,
+ u8 assocRespLen, u8 *assocInfo, A_UINT16 protocolReasonStatus)
{
- A_UINT8 i;
+ u8 i;
unsigned long flags;
union iwreq_data wrqu;
{
void *osbuf = NULL;
A_INT8 i;
- A_UINT8 size, *buf;
+ u8 size, *buf;
int ret = A_OK;
size = cmd->evt_buf_sz + 4;
}
A_NETBUF_PUT(osbuf, size);
- buf = (A_UINT8 *)A_NETBUF_DATA(osbuf);
+ buf = (u8 *)A_NETBUF_DATA(osbuf);
/* First 2-bytes carry HCI event/ACL data type
* the next 2 are free
*/
}
void
-ar6000_tkip_micerr_event(AR_SOFTC_T *ar, A_UINT8 keyid, bool ismcast)
+ar6000_tkip_micerr_event(AR_SOFTC_T *ar, u8 keyid, bool ismcast)
{
static const char *tag = "MLME-MICHAELMICFAILURE.indication";
char buf[128];
}
void
-ar6000_targetStats_event(AR_SOFTC_T *ar, A_UINT8 *ptr, A_UINT32 len)
+ar6000_targetStats_event(AR_SOFTC_T *ar, u8 *ptr, A_UINT32 len)
{
- A_UINT8 ac;
+ u8 ac;
if(ar->arNetworkType == AP_NETWORK) {
WMI_AP_MODE_STAT *p = (WMI_AP_MODE_STAT *)ptr;
A_PRINTF("rssi Threshold range = %d tag = %d rssi = %d\n", newThreshold,
userRssiThold.tag, userRssiThold.rssi);
- ar6000_send_event_to_app(ar, WMI_RSSI_THRESHOLD_EVENTID,(A_UINT8 *)&userRssiThold, sizeof(USER_RSSI_THOLD));
+ ar6000_send_event_to_app(ar, WMI_RSSI_THRESHOLD_EVENTID,(u8 *)&userRssiThold, sizeof(USER_RSSI_THOLD));
}
if (source == APP_HB_CHALLENGE) {
/* Report it to the app in case it wants a positive acknowledgement */
ar6000_send_event_to_app(ar, WMIX_HB_CHALLENGE_RESP_EVENTID,
- (A_UINT8 *)&cookie, sizeof(cookie));
+ (u8 *)&cookie, sizeof(cookie));
} else {
/* This would ignore the replys that come in after their due time */
if (cookie == ar->arHBChallengeResp.seqNum) {
void
-ar6000_cac_event(AR_SOFTC_T *ar, A_UINT8 ac, A_UINT8 cacIndication,
- A_UINT8 statusCode, A_UINT8 *tspecSuggestion)
+ar6000_cac_event(AR_SOFTC_T *ar, u8 ac, u8 cacIndication,
+ u8 statusCode, u8 *tspecSuggestion)
{
WMM_TSPEC_IE *tspecIe;
void
ar6000_roam_tbl_event(AR_SOFTC_T *ar, WMI_TARGET_ROAM_TBL *pTbl)
{
- A_UINT8 i;
+ u8 i;
A_PRINTF("ROAM TABLE NO OF ENTRIES is %d ROAM MODE is %d\n",
pTbl->numEntries, pTbl->roamMode);
}
void
-ar6000_wow_list_event(struct ar6_softc *ar, A_UINT8 num_filters, WMI_GET_WOW_LIST_REPLY *wow_reply)
+ar6000_wow_list_event(struct ar6_softc *ar, u8 num_filters, WMI_GET_WOW_LIST_REPLY *wow_reply)
{
- A_UINT8 i,j;
+ u8 i,j;
/*Each event now contains exactly one filter, see bug 26613*/
A_PRINTF("WOW pattern %d of %d patterns\n", wow_reply->this_filter_num, wow_reply->num_filters);
}
void
-ar6000_bssInfo_event_rx(AR_SOFTC_T *ar, A_UINT8 *datap, int len)
+ar6000_bssInfo_event_rx(AR_SOFTC_T *ar, u8 *datap, int len)
{
struct sk_buff *skb;
WMI_BSS_INFO_HDR *bih = (WMI_BSS_INFO_HDR *)datap;
if(logWmiRawMsgs) {
A_PRINTF("WMI cmd send, msgNo %d :", wmiSendCmdNum);
for(i = 0; i < a_netbuf_to_len(osbuf); i++)
- A_PRINTF("%x ", ((A_UINT8 *)a_netbuf_to_data(osbuf))[i]);
+ A_PRINTF("%x ", ((u8 *)a_netbuf_to_data(osbuf))[i]);
A_PRINTF("\n");
}
}
/* indicate tx activity or inactivity on a WMI stream */
-void ar6000_indicate_tx_activity(void *devt, A_UINT8 TrafficClass, bool Active)
+void ar6000_indicate_tx_activity(void *devt, u8 TrafficClass, bool Active)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
HTC_ENDPOINT_ID eid ;
}
void
-ar6000_btcoex_config_event(struct ar6_softc *ar, A_UINT8 *ptr, A_UINT32 len)
+ar6000_btcoex_config_event(struct ar6_softc *ar, u8 *ptr, A_UINT32 len)
{
WMI_BTCOEX_CONFIG_EVENT *pBtcoexConfig = (WMI_BTCOEX_CONFIG_EVENT *)ptr;
}
void
-ar6000_btcoex_stats_event(struct ar6_softc *ar, A_UINT8 *ptr, A_UINT32 len)
+ar6000_btcoex_stats_event(struct ar6_softc *ar, u8 *ptr, A_UINT32 len)
{
WMI_BTCOEX_STATS_EVENT *pBtcoexStats = (WMI_BTCOEX_STATS_EVENT *)ptr;
*/
#define EVENT_ID_LEN 2
void ar6000_send_event_to_app(AR_SOFTC_T *ar, A_UINT16 eventId,
- A_UINT8 *datap, int len)
+ u8 *datap, int len)
{
#if (WIRELESS_EXT >= 15)
* includes the event ID and event content.
*/
void ar6000_send_generic_event_to_app(AR_SOFTC_T *ar, A_UINT16 eventId,
- A_UINT8 *datap, int len)
+ u8 *datap, int len)
{
#if (WIRELESS_EXT >= 18)
}
void
-ar6000_snrThresholdEvent_rx(void *devt, WMI_SNR_THRESHOLD_VAL newThreshold, A_UINT8 snr)
+ar6000_snrThresholdEvent_rx(void *devt, WMI_SNR_THRESHOLD_VAL newThreshold, u8 snr)
{
WMI_SNR_THRESHOLD_EVENT event;
AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
event.range = newThreshold;
event.snr = snr;
- ar6000_send_event_to_app(ar, WMI_SNR_THRESHOLD_EVENTID, (A_UINT8 *)&event,
+ ar6000_send_event_to_app(ar, WMI_SNR_THRESHOLD_EVENTID, (u8 *)&event,
sizeof(WMI_SNR_THRESHOLD_EVENT));
}
void
-ar6000_lqThresholdEvent_rx(void *devt, WMI_LQ_THRESHOLD_VAL newThreshold, A_UINT8 lq)
+ar6000_lqThresholdEvent_rx(void *devt, WMI_LQ_THRESHOLD_VAL newThreshold, u8 lq)
{
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("lq threshold range %d, lq %d\n", newThreshold, lq));
}
}
void
-ar6000_keepalive_rx(void *devt, A_UINT8 configured)
+ar6000_keepalive_rx(void *devt, u8 configured)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
}
void
-ar6000_pmkid_list_event(void *devt, A_UINT8 numPMKID, WMI_PMKID *pmkidList,
- A_UINT8 *bssidList)
+ar6000_pmkid_list_event(void *devt, u8 numPMKID, WMI_PMKID *pmkidList,
+ u8 *bssidList)
{
- A_UINT8 i, j;
+ u8 i, j;
A_PRINTF("Number of Cached PMKIDs is %d\n", numPMKID);
for (j = 0; j < WMI_PMKID_LEN; j++) {
A_PRINTF("%2.2x", pmkidList->pmkid[j]);
}
- pmkidList = (WMI_PMKID *)((A_UINT8 *)pmkidList + ATH_MAC_LEN +
+ pmkidList = (WMI_PMKID *)((u8 *)pmkidList + ATH_MAC_LEN +
WMI_PMKID_LEN);
}
}
-void ar6000_pspoll_event(AR_SOFTC_T *ar,A_UINT8 aid)
+void ar6000_pspoll_event(AR_SOFTC_T *ar,u8 aid)
{
sta_t *conn=NULL;
bool isPsqEmpty = false;
void
read_rssi_compensation_param(AR_SOFTC_T *ar)
{
- A_UINT8 *cust_data_ptr;
+ u8 *cust_data_ptr;
//#define RSSICOMPENSATION_PRINT
A_INT16 i;
cust_data_ptr = ar6000_get_cust_data_buffer(ar->arTargetType);
for (i=0; i<16; i++) {
- A_PRINTF("cust_data_%d = %x \n", i, *(A_UINT8 *)cust_data_ptr);
+ A_PRINTF("cust_data_%d = %x \n", i, *(u8 *)cust_data_ptr);
cust_data_ptr += 1;
}
#endif
}
#ifdef WAPI_ENABLE
-void ap_wapi_rekey_event(AR_SOFTC_T *ar, A_UINT8 type, A_UINT8 *mac)
+void ap_wapi_rekey_event(AR_SOFTC_T *ar, u8 type, u8 *mac)
{
union iwreq_data wrqu;
char buf[20];
#ifdef USER_KEYS
static int
-ar6000_reinstall_keys(AR_SOFTC_T *ar, A_UINT8 key_op_ctrl)
+ar6000_reinstall_keys(AR_SOFTC_T *ar, u8 key_op_ctrl)
{
int status = A_OK;
struct ieee80211req_key *uik = &ar->user_saved_keys.ucast_ik;
if (uik->ik_keylen) {
status = wmi_addKey_cmd(ar->arWmi, uik->ik_keyix,
ar->user_saved_keys.keyType, PAIRWISE_USAGE,
- uik->ik_keylen, (A_UINT8 *)&uik->ik_keyrsc,
+ uik->ik_keylen, (u8 *)&uik->ik_keyrsc,
uik->ik_keydata, key_op_ctrl, uik->ik_macaddr, SYNC_BEFORE_WMIFLAG);
}
if (bik->ik_keylen) {
status = wmi_addKey_cmd(ar->arWmi, bik->ik_keyix,
ar->user_saved_keys.keyType, GROUP_USAGE,
- bik->ik_keylen, (A_UINT8 *)&bik->ik_keyrsc,
+ bik->ik_keylen, (u8 *)&bik->ik_keyrsc,
bik->ik_keydata, key_op_ctrl, bik->ik_macaddr, NO_SYNC_WMIFLAG);
}
} else {
}
int
-is_iwioctl_allowed(A_UINT8 mode, A_UINT16 cmd)
+is_iwioctl_allowed(u8 mode, A_UINT16 cmd)
{
if(cmd >= SIOCSIWCOMMIT && cmd <= SIOCGIWPOWER) {
cmd -= SIOCSIWCOMMIT;
}
int
-is_xioctl_allowed(A_UINT8 mode, int cmd)
+is_xioctl_allowed(u8 mode, int cmd)
{
if(sizeof(xioctl_filter)-1 < cmd) {
A_PRINTF("Filter for this cmd=%d not defined\n",cmd);
ik->ik_keylen);
status = wmi_addKey_cmd(ar->arWmi, ik->ik_keyix, WAPI_CRYPT, keyUsage,
- ik->ik_keylen, (A_UINT8 *)&ik->ik_keyrsc,
+ ik->ik_keylen, (u8 *)&ik->ik_keyrsc,
ik->ik_keydata, KEY_OP_INIT_VAL, ik->ik_macaddr,
SYNC_BOTH_WMIFLAG);
void ar6000_peer_event(
void *context,
- A_UINT8 eventCode,
- A_UINT8 *macAddr)
+ u8 eventCode,
+ u8 *macAddr)
{
- A_UINT8 pos;
+ u8 pos;
for (pos=0;pos<6;pos++)
printk("%02x: ",*(macAddr+pos));
struct in_ifaddr **ifap = NULL;
struct in_ifaddr *ifa = NULL;
struct in_device *in_dev;
- A_UINT8 macMask[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+ u8 macMask[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
int status;
WMI_ADD_WOW_PATTERN_CMD addWowCmd = { .filter = { 0 } };
WMI_DEL_WOW_PATTERN_CMD delWowCmd;
}
if (pSleepEvent) {
AR_DEBUG_PRINTF(ATH_DEBUG_PM, ("SENT WLAN Sleep Event %d\n", wmiSleepEvent.sleepState));
- ar6000_send_event_to_app(ar, WMI_REPORT_SLEEP_STATE_EVENTID, (A_UINT8*)pSleepEvent,
+ ar6000_send_event_to_app(ar, WMI_REPORT_SLEEP_STATE_EVENTID, (u8 *)pSleepEvent,
sizeof(WMI_REPORT_SLEEP_STATE_EVENTID));
}
}
{
int status;
HTC_SERVICE_CONNECT_RESP response;
- A_UINT8 streamNo;
+ u8 streamNo;
HTC_SERVICE_CONNECT_REQ connect;
do {
A_MEMZERO(&connect,sizeof(connect));
/* pass the stream ID as meta data to the RAW streams service */
- streamNo = (A_UINT8)StreamID;
+ streamNo = (u8)StreamID;
connect.pMetaData = &streamNo;
- connect.MetaDataLength = sizeof(A_UINT8);
+ connect.MetaDataLength = sizeof(u8);
/* these fields are the same for all endpoints */
connect.EpCallbacks.pContext = ar;
connect.EpCallbacks.EpTxComplete = ar6000_htc_raw_write_cb;
struct sk_buff *skb = (struct sk_buff *)osbuf;
ar6k_hci_pal_info_t *pHciPalInfo;
bool success = false;
- A_UINT8 btType = 0;
+ u8 btType = 0;
pHciPalInfo = (ar6k_hci_pal_info_t *)pHciPal;
do {
static int
ar6k_set_cipher(AR_SOFTC_T *ar, A_UINT32 cipher, bool ucast)
{
- A_UINT8 *ar_cipher = ucast ? &ar->arPairwiseCrypto :
+ u8 *ar_cipher = ucast ? &ar->arPairwiseCrypto :
&ar->arGroupCrypto;
- A_UINT8 *ar_cipher_len = ucast ? &ar->arPairwiseCryptoLen :
+ u8 *ar_cipher_len = ucast ? &ar->arPairwiseCryptoLen :
&ar->arGroupCryptoLen;
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,
void
ar6k_cfg80211_connect_event(AR_SOFTC_T *ar, A_UINT16 channel,
- A_UINT8 *bssid, A_UINT16 listenInterval,
+ u8 *bssid, A_UINT16 listenInterval,
A_UINT16 beaconInterval,NETWORK_TYPE networkType,
- A_UINT8 beaconIeLen, A_UINT8 assocReqLen,
- A_UINT8 assocRespLen, A_UINT8 *assocInfo)
+ u8 beaconIeLen, u8 assocReqLen,
+ u8 assocRespLen, u8 *assocInfo)
{
A_UINT16 size = 0;
A_UINT16 capability = 0;
struct ieee80211_mgmt *mgmt = NULL;
struct ieee80211_channel *ibss_channel = NULL;
s32 signal = 50 * 100;
- A_UINT8 ie_buf_len = 0;
+ u8 ie_buf_len = 0;
unsigned char ie_buf[256];
unsigned char *ptr_ie_buf = ie_buf;
unsigned char *ieeemgmtbuf = NULL;
- A_UINT8 source_mac[ATH_MAC_LEN];
+ u8 source_mac[ATH_MAC_LEN];
- A_UINT8 assocReqIeOffset = sizeof(A_UINT16) + /* capinfo*/
+ u8 assocReqIeOffset = sizeof(A_UINT16) + /* capinfo*/
sizeof(A_UINT16); /* listen interval */
- A_UINT8 assocRespIeOffset = sizeof(A_UINT16) + /* capinfo*/
+ u8 assocRespIeOffset = sizeof(A_UINT16) + /* capinfo*/
sizeof(A_UINT16) + /* status Code */
sizeof(A_UINT16); /* associd */
- A_UINT8 *assocReqIe = assocInfo + beaconIeLen + assocReqIeOffset;
- A_UINT8 *assocRespIe = assocInfo + beaconIeLen + assocReqLen + assocRespIeOffset;
+ u8 *assocReqIe = assocInfo + beaconIeLen + assocReqIeOffset;
+ u8 *assocRespIe = assocInfo + beaconIeLen + assocReqLen + assocRespIeOffset;
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s: \n", __func__));
}
void
-ar6k_cfg80211_disconnect_event(AR_SOFTC_T *ar, A_UINT8 reason,
- A_UINT8 *bssid, A_UINT8 assocRespLen,
- A_UINT8 *assocInfo, A_UINT16 protocolReasonStatus)
+ar6k_cfg80211_disconnect_event(AR_SOFTC_T *ar, u8 reason,
+ u8 *bssid, u8 assocRespLen,
+ u8 *assocInfo, A_UINT16 protocolReasonStatus)
{
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s: reason=%u\n", __func__, reason));
if(request->n_ssids &&
request->ssids[0].ssid_len) {
- A_UINT8 i;
+ u8 i;
if(request->n_ssids > MAX_PROBED_SSID_INDEX) {
request->n_ssids = MAX_PROBED_SSID_INDEX;
if(ar->scan_request->n_ssids &&
ar->scan_request->ssids[0].ssid_len) {
- A_UINT8 i;
+ u8 i;
for (i = 0; i < ar->scan_request->n_ssids; i++) {
wmi_probedSsid_cmd(ar->arWmi, i, DISABLE_SSID_FLAG,
static int
ar6k_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
- A_UINT8 key_index, bool pairwise, const A_UINT8 *mac_addr,
+ u8 key_index, bool pairwise, const u8 *mac_addr,
struct key_params *params)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(ndev);
struct ar_key *key = NULL;
- A_UINT8 key_usage;
- A_UINT8 key_type;
+ u8 key_usage;
+ u8 key_type;
int status = 0;
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s:\n", __func__));
ar->arDefTxKeyIndex = key_index;
status = wmi_addKey_cmd(ar->arWmi, ar->arDefTxKeyIndex, key_type, key_usage,
key->key_len, key->seq, key->key, KEY_OP_INIT_VAL,
- (A_UINT8*)mac_addr, SYNC_BOTH_WMIFLAG);
+ (u8 *)mac_addr, SYNC_BOTH_WMIFLAG);
if(status != A_OK) {
static int
ar6k_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
- A_UINT8 key_index, bool pairwise, const A_UINT8 *mac_addr)
+ u8 key_index, bool pairwise, const u8 *mac_addr)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(ndev);
static int
ar6k_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
- A_UINT8 key_index, bool pairwise, const A_UINT8 *mac_addr,
+ u8 key_index, bool pairwise, const u8 *mac_addr,
void *cookie,
void (*callback)(void *cookie, struct key_params*))
{
static int
ar6k_cfg80211_set_default_key(struct wiphy *wiphy, struct net_device *ndev,
- A_UINT8 key_index, bool unicast, bool multicast)
+ u8 key_index, bool unicast, bool multicast)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(ndev);
struct ar_key *key = NULL;
static int
ar6k_cfg80211_set_default_mgmt_key(struct wiphy *wiphy, struct net_device *ndev,
- A_UINT8 key_index)
+ u8 key_index)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(ndev);
}
void
-ar6k_cfg80211_tkip_micerr_event(AR_SOFTC_T *ar, A_UINT8 keyid, bool ismcast)
+ar6k_cfg80211_tkip_micerr_event(AR_SOFTC_T *ar, u8 keyid, bool ismcast)
{
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,
("%s: keyid %d, ismcast %d\n", __func__, keyid, ismcast));
static int
ar6k_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
- const A_UINT8 *peer,
+ const u8 *peer,
const struct cfg80211_bitrate_mask *mask)
{
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Setting rates: Not supported\n"));
ar6k_cfg80211_set_txpower(struct wiphy *wiphy, enum nl80211_tx_power_setting type, int dbm)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)wiphy_priv(wiphy);
- A_UINT8 ar_dbm;
+ u8 ar_dbm;
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s: type 0x%x, dbm %d\n", __func__, type, dbm));
/* soft mac */
static int
-wmic_ether_aton(const char *orig, A_UINT8 *eth)
+wmic_ether_aton(const char *orig, u8 *eth)
{
const char *bufp;
int i;
/* Write a word to a Target memory. */
inline void
-BMI_write_mem(A_UINT32 address, A_UINT8 *p_data, A_UINT32 sz)
+BMI_write_mem(A_UINT32 address, u8 *p_data, A_UINT32 sz)
{
BMIWriteMemory(p_bmi_device, address, (A_UCHAR*)(p_data), sz);
}
static void eeprom_type_detect(void)
{
A_UINT32 regval;
- A_UINT8 i = 0;
+ u8 i = 0;
request_8byte_read(0x100);
/* Wait for DONE_INT in SI_CS */
/* soft mac */
/* Write EEPROM data to Target RAM */
- BMI_write_mem(board_data_addr, ((A_UINT8 *)eeprom_data), EEPROM_SZ);
+ BMI_write_mem(board_data_addr, ((u8 *)eeprom_data), EEPROM_SZ);
/* Record the fact that Board Data IS initialized */
{
A_UINT32 one = 1;
BMI_write_mem(HOST_INTEREST_ITEM_ADDRESS(hi_board_data_initialized),
- (A_UINT8 *)&one, sizeof(A_UINT32));
+ (u8 *)&one, sizeof(A_UINT32));
}
disable_SI();
bool HciNormalMode; /* Actual HCI mode enabled (non-TEST)*/
bool HciRegistered; /* HCI device registered with stack */
HTC_PACKET_QUEUE HTCPacketStructHead;
- A_UINT8 *pHTCStructAlloc;
+ u8 *pHTCStructAlloc;
spinlock_t BridgeLock;
#ifdef EXPORT_HCI_BRIDGE_INTERFACE
HCI_TRANSPORT_MISC_HANDLES HCITransHdl;
AR_DEBUG_PRINTF(ATH_DEBUG_HCI_BRIDGE, ("HCI Bridge: running in test mode... \n"));
}
- pHcidevInfo->pHTCStructAlloc = (A_UINT8 *)A_MALLOC((sizeof(HTC_PACKET)) * NUM_HTC_PACKET_STRUCTS);
+ pHcidevInfo->pHTCStructAlloc = (u8 *)A_MALLOC((sizeof(HTC_PACKET)) * NUM_HTC_PACKET_STRUCTS);
if (NULL == pHcidevInfo->pHTCStructAlloc) {
status = A_NO_MEMORY;
HCI_TRANSPORT_PACKET_TYPE Type,
struct sk_buff *skb)
{
- A_UINT8 btType;
+ u8 btType;
int len;
bool success = false;
BT_HCI_EVENT_HEADER *pEvent;
#endif /* CONFIG_HOST_TCMD_SUPPORT */
struct ar_wep_key {
- A_UINT8 arKeyIndex;
- A_UINT8 arKeyLen;
- A_UINT8 arKey[64];
+ u8 arKeyIndex;
+ u8 arKeyLen;
+ u8 arKey[64];
} ;
#ifdef ATH6K_CONFIG_CFG80211
struct ar_key {
- A_UINT8 key[WLAN_MAX_KEY_LEN];
- A_UINT8 key_len;
- A_UINT8 seq[IW_ENCODE_SEQ_MAX_SIZE];
- A_UINT8 seq_len;
+ u8 key[WLAN_MAX_KEY_LEN];
+ u8 key_len;
+ u8 seq[IW_ENCODE_SEQ_MAX_SIZE];
+ u8 seq_len;
A_UINT32 cipher;
};
#endif /* ATH6K_CONFIG_CFG80211 */
struct ar_node_mapping {
- A_UINT8 macAddress[6];
- A_UINT8 epId;
- A_UINT8 txPending;
+ u8 macAddress[6];
+ u8 epId;
+ u8 txPending;
};
struct ar_cookie {
A_UINT32 frequency;
A_UINT32 seqNum;
bool outstanding;
- A_UINT8 missCnt;
- A_UINT8 missThres;
+ u8 missCnt;
+ u8 missThres;
};
/* Per STA data, used in AP mode */
typedef struct {
A_UINT16 flags;
- A_UINT8 mac[ATH_MAC_LEN];
- A_UINT8 aid;
- A_UINT8 keymgmt;
- A_UINT8 ucipher;
- A_UINT8 auth;
- A_UINT8 wpa_ie[IEEE80211_MAX_IE];
+ u8 mac[ATH_MAC_LEN];
+ u8 aid;
+ u8 keymgmt;
+ u8 ucipher;
+ u8 auth;
+ u8 wpa_ie[IEEE80211_MAX_IE];
A_NETBUF_QUEUE_T psq; /* power save q */
A_MUTEX_T psqLock;
} sta_t;
void *arWmi;
int arTxPending[ENDPOINT_MAX];
int arTotalTxDataPending;
- A_UINT8 arNumDataEndPts;
+ u8 arNumDataEndPts;
bool arWmiEnabled;
bool arWmiReady;
bool arConnected;
struct semaphore arSem;
int arSsidLen;
u_char arSsid[32];
- A_UINT8 arNextMode;
- A_UINT8 arNetworkType;
- A_UINT8 arDot11AuthMode;
- A_UINT8 arAuthMode;
- A_UINT8 arPairwiseCrypto;
- A_UINT8 arPairwiseCryptoLen;
- A_UINT8 arGroupCrypto;
- A_UINT8 arGroupCryptoLen;
- A_UINT8 arDefTxKeyIndex;
+ u8 arNextMode;
+ u8 arNetworkType;
+ u8 arDot11AuthMode;
+ u8 arAuthMode;
+ u8 arPairwiseCrypto;
+ u8 arPairwiseCryptoLen;
+ u8 arGroupCrypto;
+ u8 arGroupCryptoLen;
+ u8 arDefTxKeyIndex;
struct ar_wep_key arWepKeyList[WMI_MAX_KEY_INDEX + 1];
- A_UINT8 arBssid[6];
- A_UINT8 arReqBssid[6];
+ u8 arBssid[6];
+ u8 arReqBssid[6];
A_UINT16 arChannelHint;
A_UINT16 arBssChannel;
A_UINT16 arListenIntervalB;
struct ar6000_version arVersion;
A_UINT32 arTargetType;
A_INT8 arRssi;
- A_UINT8 arTxPwr;
+ u8 arTxPwr;
bool arTxPwrSet;
A_INT32 arBitRate;
struct net_device_stats arNetStats;
bool statsUpdatePending;
TARGET_STATS arTargetStats;
A_INT8 arMaxRetries;
- A_UINT8 arPhyCapability;
+ u8 arPhyCapability;
#ifdef CONFIG_HOST_TCMD_SUPPORT
- A_UINT8 tcmdRxReport;
+ u8 tcmdRxReport;
A_UINT32 tcmdRxTotalPkt;
A_INT32 tcmdRxRssi;
A_UINT32 tcmdPm;
#endif
AR6000_WLAN_STATE arWlanState;
struct ar_node_mapping arNodeMap[MAX_NODE_NUM];
- A_UINT8 arIbssPsEnable;
- A_UINT8 arNodeNum;
- A_UINT8 arNexEpId;
+ u8 arIbssPsEnable;
+ u8 arNodeNum;
+ u8 arNexEpId;
struct ar_cookie *arCookieList;
A_UINT32 arCookieCount;
A_UINT32 arRateMask;
- A_UINT8 arSkipScan;
+ u8 arSkipScan;
A_UINT16 arBeaconInterval;
bool arConnectPending;
bool arWmmEnabled;
struct ar_hb_chlng_resp arHBChallengeResp;
- A_UINT8 arKeepaliveConfigured;
+ u8 arKeepaliveConfigured;
A_UINT32 arMgmtFilter;
HTC_ENDPOINT_ID arAc2EpMapping[WMM_NUM_AC];
bool arAcStreamActive[WMM_NUM_AC];
- A_UINT8 arAcStreamPriMap[WMM_NUM_AC];
- A_UINT8 arHiAcStreamActivePri;
- A_UINT8 arEp2AcMapping[ENDPOINT_MAX];
+ u8 arAcStreamPriMap[WMM_NUM_AC];
+ u8 arHiAcStreamActivePri;
+ u8 arEp2AcMapping[ENDPOINT_MAX];
HTC_ENDPOINT_ID arControlEp;
#ifdef HTC_RAW_INTERFACE
AR_RAW_HTC_T *arRawHtc;
struct USER_SAVEDKEYS user_saved_keys;
#endif
USER_RSSI_THOLD rssi_map[12];
- A_UINT8 arUserBssFilter;
+ u8 arUserBssFilter;
A_UINT16 ap_profile_flag; /* AP mode */
WMI_AP_ACL g_acl; /* AP mode */
sta_t sta_list[AP_MAX_NUM_STA]; /* AP mode */
- A_UINT8 sta_list_index; /* AP mode */
+ u8 sta_list_index; /* AP mode */
struct ieee80211req_key ap_mode_bkey; /* AP mode */
A_NETBUF_QUEUE_T mcastpsq; /* power save q for Mcast frames */
A_MUTEX_T mcastpsqLock;
bool DTIMExpired; /* flag to indicate DTIM expired */
- A_UINT8 intra_bss; /* enable/disable intra bss data forward */
+ u8 intra_bss; /* enable/disable intra bss data forward */
void *aggr_cntxt;
#ifndef EXPORT_HCI_BRIDGE_INTERFACE
void *hcidev_info;
#endif
void *hcipal_info;
WMI_AP_MODE_STAT arAPStats;
- A_UINT8 ap_hidden_ssid;
- A_UINT8 ap_country_code[3];
- A_UINT8 ap_wmode;
- A_UINT8 ap_dtim_period;
+ u8 ap_hidden_ssid;
+ u8 ap_country_code[3];
+ u8 ap_wmode;
+ u8 ap_dtim_period;
A_UINT16 ap_beacon_interval;
A_UINT16 arRTS;
A_UINT16 arACS; /* AP mode - Auto Channel Selection */
HTC_PACKET_QUEUE amsdu_rx_buffer_queue;
bool bIsDestroyProgress; /* flag to indicate ar6k destroy is in progress */
A_TIMER disconnect_timer;
- A_UINT8 rxMetaVersion;
+ u8 rxMetaVersion;
#ifdef WAPI_ENABLE
- A_UINT8 arWapiEnable;
+ u8 arWapiEnable;
#endif
WMI_BTCOEX_CONFIG_EVENT arBtcoexConfig;
WMI_BTCOEX_STATS_EVENT arBtcoexStats;
A_UINT16 arWlanOffConfig;
A_UINT16 arWow2Config;
#endif
- A_UINT8 scan_triggered;
+ u8 scan_triggered;
WMI_SCAN_PARAMS_CMD scParams;
#define AR_MCAST_FILTER_MAC_ADDR_SIZE 4
- A_UINT8 mcast_filters[MAC_MAX_FILTERS_PER_LIST][AR_MCAST_FILTER_MAC_ADDR_SIZE];
- A_UINT8 bdaddr[6];
+ u8 mcast_filters[MAC_MAX_FILTERS_PER_LIST][AR_MCAST_FILTER_MAC_ADDR_SIZE];
+ u8 bdaddr[6];
bool scanSpecificSsid;
#ifdef CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT
void *arApDev;
/* AP mode */
/*TODO: These routines should be moved to a file that is common across OS */
sta_t *
-ieee80211_find_conn(AR_SOFTC_T *ar, A_UINT8 *node_addr);
+ieee80211_find_conn(AR_SOFTC_T *ar, u8 *node_addr);
sta_t *
-ieee80211_find_conn_for_aid(AR_SOFTC_T *ar, A_UINT8 aid);
+ieee80211_find_conn_for_aid(AR_SOFTC_T *ar, u8 aid);
-A_UINT8
-remove_sta(AR_SOFTC_T *ar, A_UINT8 *mac, A_UINT16 reason);
+u8 remove_sta(AR_SOFTC_T *ar, u8 *mac, A_UINT16 reason);
/* HCI support */
ATH_DEBUG_DECLARE_EXTERN(wlan);
ATH_DEBUG_DECLARE_EXTERN(misc);
-extern A_UINT8 bcast_mac[];
-extern A_UINT8 null_mac[];
+extern u8 bcast_mac[];
+extern u8 null_mac[];
#ifdef __cplusplus
}
struct ar6_softc;
-void ar6000_ready_event(void *devt, A_UINT8 *datap, A_UINT8 phyCap,
+void ar6000_ready_event(void *devt, u8 *datap, u8 phyCap,
A_UINT32 sw_ver, A_UINT32 abi_ver);
int ar6000_control_tx(void *devt, void *osbuf, HTC_ENDPOINT_ID eid);
void ar6000_connect_event(struct ar6_softc *ar, A_UINT16 channel,
- A_UINT8 *bssid, A_UINT16 listenInterval,
+ u8 *bssid, A_UINT16 listenInterval,
A_UINT16 beaconInterval, NETWORK_TYPE networkType,
- A_UINT8 beaconIeLen, A_UINT8 assocReqLen,
- A_UINT8 assocRespLen,A_UINT8 *assocInfo);
-void ar6000_disconnect_event(struct ar6_softc *ar, A_UINT8 reason,
- A_UINT8 *bssid, A_UINT8 assocRespLen,
- A_UINT8 *assocInfo, A_UINT16 protocolReasonStatus);
-void ar6000_tkip_micerr_event(struct ar6_softc *ar, A_UINT8 keyid,
+ u8 beaconIeLen, u8 assocReqLen,
+ u8 assocRespLen,u8 *assocInfo);
+void ar6000_disconnect_event(struct ar6_softc *ar, u8 reason,
+ u8 *bssid, u8 assocRespLen,
+ u8 *assocInfo, A_UINT16 protocolReasonStatus);
+void ar6000_tkip_micerr_event(struct ar6_softc *ar, u8 keyid,
bool ismcast);
void ar6000_bitrate_rx(void *devt, A_INT32 rateKbps);
void ar6000_channelList_rx(void *devt, A_INT8 numChan, A_UINT16 *chanList);
void ar6000_regDomain_event(struct ar6_softc *ar, A_UINT32 regCode);
-void ar6000_txPwr_rx(void *devt, A_UINT8 txPwr);
-void ar6000_keepalive_rx(void *devt, A_UINT8 configured);
+void ar6000_txPwr_rx(void *devt, u8 txPwr);
+void ar6000_keepalive_rx(void *devt, u8 configured);
void ar6000_neighborReport_event(struct ar6_softc *ar, int numAps,
WMI_NEIGHBOR_INFO *info);
void ar6000_set_numdataendpts(struct ar6_softc *ar, A_UINT32 num);
void ar6000_scanComplete_event(struct ar6_softc *ar, int status);
-void ar6000_targetStats_event(struct ar6_softc *ar, A_UINT8 *ptr, A_UINT32 len);
+void ar6000_targetStats_event(struct ar6_softc *ar, u8 *ptr, A_UINT32 len);
void ar6000_rssiThreshold_event(struct ar6_softc *ar,
WMI_RSSI_THRESHOLD_VAL newThreshold,
A_INT16 rssi);
void ar6000_reportError_event(struct ar6_softc *, WMI_TARGET_ERROR_VAL errorVal);
-void ar6000_cac_event(struct ar6_softc *ar, A_UINT8 ac, A_UINT8 cac_indication,
- A_UINT8 statusCode, A_UINT8 *tspecSuggestion);
+void ar6000_cac_event(struct ar6_softc *ar, u8 ac, u8 cac_indication,
+ u8 statusCode, u8 *tspecSuggestion);
void ar6000_channel_change_event(struct ar6_softc *ar, A_UINT16 oldChannel, A_UINT16 newChannel);
void ar6000_hbChallengeResp_event(struct ar6_softc *, A_UINT32 cookie, A_UINT32 source);
void
ar6000_roam_data_event(struct ar6_softc *ar, WMI_TARGET_ROAM_DATA *p);
void
-ar6000_wow_list_event(struct ar6_softc *ar, A_UINT8 num_filters,
+ar6000_wow_list_event(struct ar6_softc *ar, u8 num_filters,
WMI_GET_WOW_LIST_REPLY *wow_reply);
-void ar6000_pmkid_list_event(void *devt, A_UINT8 numPMKID,
- WMI_PMKID *pmkidList, A_UINT8 *bssidList);
+void ar6000_pmkid_list_event(void *devt, u8 numPMKID,
+ WMI_PMKID *pmkidList, u8 *bssidList);
void ar6000_gpio_intr_rx(A_UINT32 intr_mask, A_UINT32 input_values);
void ar6000_gpio_data_rx(A_UINT32 reg_id, A_UINT32 value);
void ar6000_dbglog_init_done(struct ar6_softc *ar);
#ifdef SEND_EVENT_TO_APP
-void ar6000_send_event_to_app(struct ar6_softc *ar, A_UINT16 eventId, A_UINT8 *datap, int len);
-void ar6000_send_generic_event_to_app(struct ar6_softc *ar, A_UINT16 eventId, A_UINT8 *datap, int len);
+void ar6000_send_event_to_app(struct ar6_softc *ar, A_UINT16 eventId, u8 *datap, int len);
+void ar6000_send_generic_event_to_app(struct ar6_softc *ar, A_UINT16 eventId, u8 *datap, int len);
#endif
#ifdef CONFIG_HOST_TCMD_SUPPORT
-void ar6000_tcmd_rx_report_event(void *devt, A_UINT8 * results, int len);
+void ar6000_tcmd_rx_report_event(void *devt, u8 *results, int len);
#endif
void ar6000_tx_retry_err_event(void *devt);
void ar6000_snrThresholdEvent_rx(void *devt,
WMI_SNR_THRESHOLD_VAL newThreshold,
- A_UINT8 snr);
+ u8 snr);
-void ar6000_lqThresholdEvent_rx(void *devt, WMI_LQ_THRESHOLD_VAL range, A_UINT8 lqVal);
+void ar6000_lqThresholdEvent_rx(void *devt, WMI_LQ_THRESHOLD_VAL range, u8 lqVal);
void ar6000_ratemask_rx(void *devt, A_UINT32 ratemask);
int ar6000_get_driver_cfg(struct net_device *dev,
A_UINT16 cfgParam,
void *result);
-void ar6000_bssInfo_event_rx(struct ar6_softc *ar, A_UINT8 *data, int len);
+void ar6000_bssInfo_event_rx(struct ar6_softc *ar, u8 *data, int len);
void ar6000_dbglog_event(struct ar6_softc *ar, A_UINT32 dropped,
A_INT8 *buffer, A_UINT32 length);
int ar6000_dbglog_get_debug_logs(struct ar6_softc *ar);
-void ar6000_peer_event(void *devt, A_UINT8 eventCode, A_UINT8 *bssid);
+void ar6000_peer_event(void *devt, u8 eventCode, u8 *bssid);
-void ar6000_indicate_tx_activity(void *devt, A_UINT8 trafficClass, bool Active);
-HTC_ENDPOINT_ID ar6000_ac2_endpoint_id ( void * devt, A_UINT8 ac);
-A_UINT8 ar6000_endpoint_id2_ac (void * devt, HTC_ENDPOINT_ID ep );
+void ar6000_indicate_tx_activity(void *devt, u8 trafficClass, bool Active);
+HTC_ENDPOINT_ID ar6000_ac2_endpoint_id ( void * devt, u8 ac);
+u8 ar6000_endpoint_id2_ac (void * devt, HTC_ENDPOINT_ID ep );
-void ar6000_btcoex_config_event(struct ar6_softc *ar, A_UINT8 *ptr, A_UINT32 len);
+void ar6000_btcoex_config_event(struct ar6_softc *ar, u8 *ptr, A_UINT32 len);
-void ar6000_btcoex_stats_event(struct ar6_softc *ar, A_UINT8 *ptr, A_UINT32 len) ;
+void ar6000_btcoex_stats_event(struct ar6_softc *ar, u8 *ptr, A_UINT32 len) ;
void ar6000_dset_open_req(void *devt,
A_UINT32 id,
int
ar6000_ap_mode_get_wpa_ie(struct ar6_softc *ar, struct ieee80211req_wpaie *wpaie);
-int is_iwioctl_allowed(A_UINT8 mode, A_UINT16 cmd);
+int is_iwioctl_allowed(u8 mode, A_UINT16 cmd);
-int is_xioctl_allowed(A_UINT8 mode, int cmd);
+int is_xioctl_allowed(u8 mode, int cmd);
-void ar6000_pspoll_event(struct ar6_softc *ar,A_UINT8 aid);
+void ar6000_pspoll_event(struct ar6_softc *ar,u8 aid);
void ar6000_dtimexpiry_event(struct ar6_softc *ar);
#ifdef WAPI_ENABLE
int ap_set_wapi_key(struct ar6_softc *ar, void *ik);
-void ap_wapi_rekey_event(struct ar6_softc *ar, A_UINT8 type, A_UINT8 *mac);
+void ap_wapi_rekey_event(struct ar6_softc *ar, u8 type, u8 *mac);
#endif
int ar6000_connect_to_ap(struct ar6_softc *ar);
/*
* arguments:
* struct {
- * A_UINT8 streamType;
- * A_UINT8 status;
+ * u8 streamType;
+ * u8 status;
* }
* uses: WMI_SET_BT_STATUS_CMDID
*/
/*
* arguments:
* struct {
- * A_UINT8 paramType;
+ * u8 paramType;
* union {
- * A_UINT8 noSCOPkts;
+ * u8 noSCOPkts;
* BT_PARAMS_A2DP a2dpParams;
* BT_COEX_REGS regs;
* };
/* used by AR6000_IOCTL_WMI_GET_QOS_QUEUE */
struct ar6000_queuereq {
- A_UINT8 trafficClass;
+ u8 trafficClass;
A_UINT16 activeTsids;
};
A_INT16 noise_floor_calibation;
A_INT16 cs_rssi;
A_INT16 cs_aveBeacon_rssi;
- A_UINT8 cs_aveBeacon_snr;
- A_UINT8 cs_lastRoam_msec;
- A_UINT8 cs_snr;
+ u8 cs_aveBeacon_snr;
+ u8 cs_lastRoam_msec;
+ u8 cs_snr;
- A_UINT8 wow_num_host_pkt_wakeups;
- A_UINT8 wow_num_host_event_wakeups;
+ u8 wow_num_host_pkt_wakeups;
+ u8 wow_num_host_event_wakeups;
A_UINT32 arp_received;
A_UINT32 arp_matched;
} USER_RSSI_THOLD;
typedef struct user_rssi_params_t {
- A_UINT8 weight;
+ u8 weight;
A_UINT32 pollTime;
USER_RSSI_THOLD tholds[12];
} USER_RSSI_PARAMS;
void ar6k_cfg80211_scanComplete_event(AR_SOFTC_T *ar, int status);
void ar6k_cfg80211_connect_event(AR_SOFTC_T *ar, A_UINT16 channel,
- A_UINT8 *bssid, A_UINT16 listenInterval,
+ u8 *bssid, A_UINT16 listenInterval,
A_UINT16 beaconInterval,NETWORK_TYPE networkType,
- A_UINT8 beaconIeLen, A_UINT8 assocReqLen,
- A_UINT8 assocRespLen, A_UINT8 *assocInfo);
+ u8 beaconIeLen, u8 assocReqLen,
+ u8 assocRespLen, u8 *assocInfo);
-void ar6k_cfg80211_disconnect_event(AR_SOFTC_T *ar, A_UINT8 reason,
- A_UINT8 *bssid, A_UINT8 assocRespLen,
- A_UINT8 *assocInfo, A_UINT16 protocolReasonStatus);
+void ar6k_cfg80211_disconnect_event(AR_SOFTC_T *ar, u8 reason,
+ u8 *bssid, u8 assocRespLen,
+ u8 *assocInfo, A_UINT16 protocolReasonStatus);
-void ar6k_cfg80211_tkip_micerr_event(AR_SOFTC_T *ar, A_UINT8 keyid, bool ismcast);
+void ar6k_cfg80211_tkip_micerr_event(AR_SOFTC_T *ar, u8 keyid, bool ismcast);
#endif /* _AR6K_CFG80211_H_ */
#define A_CPU2BE16(x) htons(x)
#define A_CPU2BE32(x) htonl(x)
-#define A_MEMCPY(dst, src, len) memcpy((A_UINT8 *)(dst), (src), (len))
+#define A_MEMCPY(dst, src, len) memcpy((u8 *)(dst), (src), (len))
#define A_MEMZERO(addr, len) memset(addr, 0, len)
#define A_MEMCMP(addr1, addr2, len) memcmp((addr1), (addr2), (len))
#define A_MALLOC(size) kmalloc((size), GFP_KERNEL)
* (0xFF) - Allow this cmd always irrespective of mode
*/
-A_UINT8 sioctl_filter[] = {
+u8 sioctl_filter[] = {
(AP_NETWORK), /* SIOCSIWCOMMIT 0x8B00 */
(0xFF), /* SIOCGIWNAME 0x8B01 */
(0), /* SIOCSIWNWID 0x8B02 */
-A_UINT8 pioctl_filter[] = {
+u8 pioctl_filter[] = {
(INFRA_NETWORK | ADHOC_NETWORK | AP_NETWORK), /* IEEE80211_IOCTL_SETPARAM (SIOCIWFIRSTPRIV+0) */
(INFRA_NETWORK | ADHOC_NETWORK | AP_NETWORK), /* IEEE80211_IOCTL_SETKEY (SIOCIWFIRSTPRIV+1) */
(INFRA_NETWORK | ADHOC_NETWORK | AP_NETWORK), /* IEEE80211_IOCTL_DELKEY (SIOCIWFIRSTPRIV+2) */
-A_UINT8 xioctl_filter[] = {
+u8 xioctl_filter[] = {
(0xFF), /* Dummy 0 */
(0xFF), /* AR6000_XIOCTL_BMI_DONE 1 */
(0xFF), /* AR6000_XIOCTL_BMI_READ_MEMORY 2 */
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
WMI_SET_ROAM_CTRL_CMD cmd;
- A_UINT8 size = sizeof(cmd);
+ u8 size = sizeof(cmd);
if (ar->arWmiReady == false) {
return -EIO;
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
WMI_POWERSAVE_TIMERS_POLICY_CMD cmd;
- A_UINT8 size = sizeof(cmd);
+ u8 size = sizeof(cmd);
if (ar->arWmiReady == false) {
return -EIO;
#ifdef CONFIG_HOST_TCMD_SUPPORT
static int
ar6000_ioctl_tcmd_get_rx_report(struct net_device *dev,
- struct ifreq *rq, A_UINT8 *data, A_UINT32 len)
+ struct ifreq *rq, u8 *data, A_UINT32 len)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
A_UINT32 buf[4+TCMD_MAX_RATES];
}
void
-ar6000_tcmd_rx_report_event(void *devt, A_UINT8 * results, int len)
+ar6000_tcmd_rx_report_event(void *devt, u8 *results, int len)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
TCMD_CONT_RX * rx_rep = (TCMD_CONT_RX *)results;
return -EFAULT;
}
if (action == AP_CLEAR_STATS) {
- A_UINT8 i;
+ u8 i;
AR6000_SPIN_LOCK(&ar->arLock, 0);
for(i = 0; i < AP_MAX_NUM_STA; i++) {
pStats->sta[i].tx_bytes = 0;
static int
-ar6000_create_acl_data_osbuf(struct net_device *dev, A_UINT8 *userdata, void **p_osbuf)
+ar6000_create_acl_data_osbuf(struct net_device *dev, u8 *userdata, void **p_osbuf)
{
void *osbuf = NULL;
- A_UINT8 tmp_space[8];
+ u8 tmp_space[8];
HCI_ACL_DATA_PKT *acl;
- A_UINT8 hdr_size, *datap=NULL;
+ u8 hdr_size, *datap=NULL;
int ret = A_OK;
/* ACL is in data path. There is a need to create pool
break;
}
A_NETBUF_PUT(osbuf, hdr_size + acl->data_len);
- datap = (A_UINT8 *)A_NETBUF_DATA(osbuf);
+ datap = (u8 *)A_NETBUF_DATA(osbuf);
/* Real copy to osbuf */
acl = (HCI_ACL_DATA_PKT *)(datap);
}
status = wmi_addKey_cmd(ar->arWmi, ik->ik_keyix, keyType, keyUsage,
- ik->ik_keylen, (A_UINT8 *)&ik->ik_keyrsc,
+ ik->ik_keylen, (u8 *)&ik->ik_keyrsc,
ik->ik_keydata, KEY_OP_INIT_VAL, ik->ik_macaddr,
SYNC_BOTH_WMIFLAG);
ret = -EFAULT;
goto ioctl_done;
} else {
- wmi_test_cmd(ar->arWmi,(A_UINT8 *)&txCmd, sizeof(TCMD_CONT_TX));
+ wmi_test_cmd(ar->arWmi,(u8 *)&txCmd, sizeof(TCMD_CONT_TX));
}
}
break;
case TCMD_CONT_RX_FILTER:
case TCMD_CONT_RX_SETMAC:
case TCMD_CONT_RX_SET_ANT_SWITCH_TABLE:
- wmi_test_cmd(ar->arWmi,(A_UINT8 *)&rxCmd,
+ wmi_test_cmd(ar->arWmi,(u8 *)&rxCmd,
sizeof(TCMD_CONT_RX));
tcmdRxFreq = rxCmd.u.para.freq;
break;
case TCMD_CONT_RX_REPORT:
ar6000_ioctl_tcmd_get_rx_report(dev, rq,
- (A_UINT8 *)&rxCmd, sizeof(TCMD_CONT_RX));
+ (u8 *)&rxCmd, sizeof(TCMD_CONT_RX));
break;
default:
A_PRINTF("Unknown Cont Rx mode: %d\n",rxCmd.act);
goto ioctl_done;
}
ar->tcmdPm = pmCmd.mode;
- wmi_test_cmd(ar->arWmi, (A_UINT8*)&pmCmd, sizeof(TCMD_PM));
+ wmi_test_cmd(ar->arWmi, (u8 *)&pmCmd, sizeof(TCMD_PM));
}
break;
#endif /* CONFIG_HOST_TCMD_SUPPORT */
case AR6000_IOCTL_WMI_SET_ASSOC_INFO:
{
WMI_SET_ASSOC_INFO_CMD cmd;
- A_UINT8 assocInfo[WMI_MAX_ASSOC_INFO_LEN];
+ u8 assocInfo[WMI_MAX_ASSOC_INFO_LEN];
if (ar->arWmiReady == false) {
ret = -EIO;
case AR6000_XIOCTL_OPT_SEND_FRAME:
{
WMI_OPT_TX_FRAME_CMD optTxFrmCmd;
- A_UINT8 data[MAX_OPT_DATA_LEN];
+ u8 data[MAX_OPT_DATA_LEN];
if (ar->arWmiReady == false) {
ret = -EIO;
case AR6000_XIOCTL_WMI_SET_APPIE:
{
WMI_SET_APPIE_CMD appIEcmd;
- A_UINT8 appIeInfo[IEEE80211_APPIE_FRAME_MAX_LEN];
+ u8 appIeInfo[IEEE80211_APPIE_FRAME_MAX_LEN];
A_UINT32 fType,ieLen;
if (ar->arWmiReady == false) {
#define WOW_MASK_SIZE 64
WMI_ADD_WOW_PATTERN_CMD cmd;
- A_UINT8 mask_data[WOW_PATTERN_SIZE]={0};
- A_UINT8 pattern_data[WOW_PATTERN_SIZE]={0};
+ u8 mask_data[WOW_PATTERN_SIZE]={0};
+ u8 pattern_data[WOW_PATTERN_SIZE]={0};
do {
if (ar->arWmiReady == false) {
/* note, this is used for testing (mbox ping testing), indicate activity
* change using the stream ID as the traffic class */
ar6000_indicate_tx_activity(ar,
- (A_UINT8)data.StreamID,
+ (u8)data.StreamID,
data.Active ? true : false);
}
break;
break;
case AR6000_XIOCTL_AP_HIDDEN_SSID:
{
- A_UINT8 hidden_ssid;
+ u8 hidden_ssid;
if (ar->arWmiReady == false) {
ret = -EIO;
} else if (copy_from_user(&hidden_ssid, userdata, sizeof(hidden_ssid))) {
if (ar->arWmiReady == false) {
ret = -EIO;
} else {
- A_UINT8 i;
+ u8 i;
ap_get_sta_t temp;
A_MEMZERO(&temp, sizeof(temp));
for(i=0;i<AP_MAX_NUM_STA;i++) {
}
case AR6000_XIOCTL_AP_SET_NUM_STA:
{
- A_UINT8 num_sta;
+ u8 num_sta;
if (ar->arWmiReady == false) {
ret = -EIO;
} else if (copy_from_user(&num_sta, userdata, sizeof(num_sta))) {
}
case AR6000_XIOCTL_AP_SET_ACL_POLICY:
{
- A_UINT8 policy;
+ u8 policy;
if (ar->arWmiReady == false) {
ret = -EIO;
} else if (copy_from_user(&policy, userdata, sizeof(policy))) {
}
case AR6000_XIOCTL_AP_INTRA_BSS_COMM:
{
- A_UINT8 intra=0;
+ u8 intra=0;
if (ar->arWmiReady == false) {
ret = -EIO;
} else if (copy_from_user(&intra, userdata, sizeof(intra))) {
void *osbuf = NULL;
if (ar->arWmiReady == false) {
ret = -EIO;
- } else if (ar6000_create_acl_data_osbuf(dev, (A_UINT8*)userdata, &osbuf) != A_OK) {
+ } else if (ar6000_create_acl_data_osbuf(dev, (u8 *)userdata, &osbuf) != A_OK) {
ret = -EIO;
} else {
if (wmi_data_hdr_add(ar->arWmi, osbuf, DATA_MSGTYPE, 0, WMI_DATA_HDR_DATA_TYPE_ACL,0,NULL) != A_OK) {
char tmp_buf[512];
A_INT8 i;
WMI_HCI_CMD *cmd = (WMI_HCI_CMD *)tmp_buf;
- A_UINT8 size;
+ u8 size;
size = sizeof(cmd->cmd_buf_sz);
if (ar->arWmiReady == false) {
{
if (ar->arWmiReady == false) {
ret = -EIO;
- } else if(copy_to_user((A_UINT8 *)rq->ifr_data,
- &ar->ap_wmode, sizeof(A_UINT8))) {
+ } else if(copy_to_user((u8 *)rq->ifr_data,
+ &ar->ap_wmode, sizeof(u8))) {
ret = -EFAULT;
}
break;
}
rq->ifr_ifru.ifru_ivalue = ar->arWlanState; /* return value */
- ar6000_send_event_to_app(ar, WMI_REPORT_SLEEP_STATE_EVENTID, (A_UINT8*)&wmiSleepEvent,
+ ar6000_send_event_to_app(ar, WMI_REPORT_SLEEP_STATE_EVENTID, (u8 *)&wmiSleepEvent,
sizeof(WMI_REPORT_SLEEP_STATE_EVENTID));
break;
}
return ret;
}
-A_UINT8 mac_cmp_wild(A_UINT8 *mac, A_UINT8 *new_mac, A_UINT8 wild, A_UINT8 new_wild)
+u8 mac_cmp_wild(u8 *mac, u8 *new_mac, u8 wild, u8 new_wild)
{
- A_UINT8 i;
+ u8 i;
for(i=0;i<ATH_MAC_LEN;i++) {
if((wild & 1<<i) && (new_wild & 1<<i)) continue;
return 0;
}
-A_UINT8 acl_add_del_mac(WMI_AP_ACL *a, WMI_AP_ACL_MAC_CMD *acl)
+u8 acl_add_del_mac(WMI_AP_ACL *a, WMI_AP_ACL_MAC_CMD *acl)
{
A_INT8 already_avail=-1, free_slot=-1, i;
}
#endif /* WIRELESS_EXT > 14 */
-static A_UINT8
-get_bss_phy_capability(bss_t *bss)
+static u8 get_bss_phy_capability(bss_t *bss)
{
- A_UINT8 capability = 0;
+ u8 capability = 0;
struct ieee80211_common_ie *cie = &bss->ni_cie;
#define CHAN_IS_11A(x) (!((x >= 2412) && (x <= 2484)))
if (CHAN_IS_11A(cie->ie_chan)) {
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
int status;
- A_UINT8 arNetworkType;
- A_UINT8 prevMode = ar->arNetworkType;
+ u8 arNetworkType;
+ u8 prevMode = ar->arNetworkType;
if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
}
return 0;
} else if(ar->arNetworkType == AP_NETWORK) {
- A_UINT8 ctr;
+ u8 ctr;
struct sk_buff *skb;
/* We are switching from AP to STA | IBSS mode, cleanup the AP state */
void ar6000_install_static_wep_keys(AR_SOFTC_T *ar)
{
- A_UINT8 index;
- A_UINT8 keyUsage;
+ u8 index;
+ u8 keyUsage;
for (index = WMI_MIN_KEY_INDEX; index <= WMI_MAX_KEY_INDEX; index++) {
if (ar->arWepKeyList[index].arKeyLen) {
struct iw_param *rrq, char *extra)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
- A_UINT8 dbM;
+ u8 dbM;
if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
struct iw_point *erq, char *key)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
- A_UINT8 keyIndex;
+ u8 keyIndex;
struct ar_wep_key *wk;
if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
#ifdef WAPI_ENABLE
- A_UINT8 *ie = erq->pointer;
- A_UINT8 ie_type = ie[0];
+ u8 *ie = erq->pointer;
+ u8 ie_type = ie[0];
A_UINT16 ie_length = erq->length;
- A_UINT8 wapi_ie[128];
+ u8 wapi_ie[128];
#endif
if (ar->arWmiReady == false) {
switch (pmksa->cmd) {
case IW_PMKSA_ADD:
- status = wmi_setPmkid_cmd(ar->arWmi, (A_UINT8*)pmksa->bssid.sa_data, pmksa->pmkid, true);
+ status = wmi_setPmkid_cmd(ar->arWmi, (u8 *)pmksa->bssid.sa_data, pmksa->pmkid, true);
break;
case IW_PMKSA_REMOVE:
- status = wmi_setPmkid_cmd(ar->arWmi, (A_UINT8*)pmksa->bssid.sa_data, pmksa->pmkid, false);
+ status = wmi_setPmkid_cmd(ar->arWmi, (u8 *)pmksa->bssid.sa_data, pmksa->pmkid, false);
break;
case IW_PMKSA_FLUSH:
if (ar->arConnected == true) {
struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
KEY_USAGE keyUsage = 0;
A_INT32 keyLen;
- A_UINT8 *keyData;
+ u8 *keyData;
A_INT32 index;
A_UINT32 *PN;
A_INT32 i;
int status;
- A_UINT8 wapiKeyRsc[16];
+ u8 wapiKeyRsc[16];
CRYPTO_TYPE keyType = WAPI_CRYPT;
- const A_UINT8 broadcastMac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+ const u8 broadcastMac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
index = erq->flags & IW_ENCODE_INDEX;
if (index && (((index - 1) < WMI_MIN_KEY_INDEX) ||
if (index < 0 || index > 4) {
return -EIO;
}
- keyData = (A_UINT8 *)(ext + 1);
+ keyData = (u8 *)(ext + 1);
keyLen = erq->length - sizeof(struct iw_encode_ext);
A_MEMCPY(wapiKeyRsc, ext->tx_seq, sizeof(wapiKeyRsc));
struct iw_encode_ext *ext;
KEY_USAGE keyUsage;
A_INT32 keyLen;
- A_UINT8 *keyData;
- A_UINT8 keyRsc[8];
+ u8 *keyData;
+ u8 keyRsc[8];
int status;
CRYPTO_TYPE keyType;
#ifdef USER_KEYS
}
/* key follows iw_encode_ext */
- keyData = (A_UINT8 *)(ext + 1);
+ keyData = (u8 *)(ext + 1);
switch (ext->alg) {
case IW_ENCODE_ALG_WEP:
status = wmi_addKey_cmd(ar->arWmi, index, keyType, keyUsage,
keyLen, keyRsc,
keyData, KEY_OP_INIT_VAL,
- (A_UINT8*)ext->addr.sa_data,
+ (u8 *)ext->addr.sa_data,
SYNC_BOTH_WMIFLAG);
if (status != A_OK) {
return -EIO;
struct iw_request_info *info,
char *name, char *extra)
{
- A_UINT8 capability;
+ u8 capability;
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
if (data->pointer && data->length == sizeof(struct iw_mlme)) {
- A_UINT8 arNetworkType;
+ u8 arNetworkType;
struct iw_mlme mlme;
if (copy_from_user(&mlme, data->pointer, sizeof(struct iw_mlme)))
}RXTID_STATS;
typedef struct {
- A_UINT8 aggr_sz; /* config value of aggregation size */
- A_UINT8 timerScheduled;
+ u8 aggr_sz; /* config value of aggregation size */
+ u8 timerScheduled;
A_TIMER timer; /* timer for returning held up pkts in re-order que */
void *dev; /* dev handle */
RX_CALLBACK rx_fn; /* callback function to return frames; to upper layer */
aggr_timeout(A_ATH_TIMER arg);
static void
-aggr_deque_frms(AGGR_INFO *p_aggr, A_UINT8 tid, A_UINT16 seq_no, A_UINT8 order);
+aggr_deque_frms(AGGR_INFO *p_aggr, u8 tid, A_UINT16 seq_no, u8 order);
static void
aggr_dispatch_frames(AGGR_INFO *p_aggr, A_NETBUF_QUEUE_T *q);
{
AGGR_INFO *p_aggr = NULL;
RXTID *rxtid;
- A_UINT8 i;
+ u8 i;
int status = A_OK;
A_PRINTF("In aggr_init..\n");
/* utility function to clear rx hold_q for a tid */
static void
-aggr_delete_tid_state(AGGR_INFO *p_aggr, A_UINT8 tid)
+aggr_delete_tid_state(AGGR_INFO *p_aggr, u8 tid)
{
RXTID *rxtid;
RXTID_STATS *stats;
{
AGGR_INFO *p_aggr = (AGGR_INFO *)cntxt;
RXTID *rxtid;
- A_UINT8 i, k;
+ u8 i, k;
A_PRINTF("%s(): aggr = %p\n",_A_FUNCNAME_, p_aggr);
A_ASSERT(p_aggr);
void
-aggr_process_bar(void *cntxt, A_UINT8 tid, A_UINT16 seq_no)
+aggr_process_bar(void *cntxt, u8 tid, A_UINT16 seq_no)
{
AGGR_INFO *p_aggr = (AGGR_INFO *)cntxt;
RXTID_STATS *stats;
void
-aggr_recv_addba_req_evt(void *cntxt, A_UINT8 tid, A_UINT16 seq_no, A_UINT8 win_sz)
+aggr_recv_addba_req_evt(void *cntxt, u8 tid, A_UINT16 seq_no, u8 win_sz)
{
AGGR_INFO *p_aggr = (AGGR_INFO *)cntxt;
RXTID *rxtid;
}
void
-aggr_recv_delba_req_evt(void *cntxt, A_UINT8 tid)
+aggr_recv_delba_req_evt(void *cntxt, u8 tid)
{
AGGR_INFO *p_aggr = (AGGR_INFO *)cntxt;
RXTID *rxtid;
}
static void
-aggr_deque_frms(AGGR_INFO *p_aggr, A_UINT8 tid, A_UINT16 seq_no, A_UINT8 order)
+aggr_deque_frms(AGGR_INFO *p_aggr, u8 tid, A_UINT16 seq_no, u8 order)
{
RXTID *rxtid;
OSBUF_HOLD_Q *node;
{
void *new_buf;
A_UINT16 frame_8023_len, payload_8023_len, mac_hdr_len, amsdu_len;
- A_UINT8 *framep;
+ u8 *framep;
/* Frame format at this point:
* [DIX hdr | 802.3 | 802.3 | ... | 802.3]
}
void
-aggr_process_recv_frm(void *cntxt, A_UINT8 tid, A_UINT16 seq_no, bool is_amsdu, void **osbuf)
+aggr_process_recv_frm(void *cntxt, u8 tid, A_UINT16 seq_no, bool is_amsdu, void **osbuf)
{
AGGR_INFO *p_aggr = (AGGR_INFO *)cntxt;
RXTID *rxtid;
void
aggr_reset_state(void *cntxt)
{
- A_UINT8 tid;
+ u8 tid;
AGGR_INFO *p_aggr = (AGGR_INFO *)cntxt;
A_ASSERT(p_aggr);
static void
aggr_timeout(A_ATH_TIMER arg)
{
- A_UINT8 i,j;
+ u8 i,j;
AGGR_INFO *p_aggr = (AGGR_INFO *)arg;
RXTID *rxtid;
RXTID_STATS *stats;
AGGR_INFO *p_aggr = (AGGR_INFO *)cntxt;
RXTID *rxtid;
RXTID_STATS *stats;
- A_UINT8 i;
+ u8 i;
*log_buf = &p_aggr->pkt_log;
A_PRINTF("\n\n================================================\n");
* generic definitions for IEEE 802.11 frames
*/
PREPACK struct ieee80211_frame {
- A_UINT8 i_fc[2];
- A_UINT8 i_dur[2];
- A_UINT8 i_addr1[IEEE80211_ADDR_LEN];
- A_UINT8 i_addr2[IEEE80211_ADDR_LEN];
- A_UINT8 i_addr3[IEEE80211_ADDR_LEN];
- A_UINT8 i_seq[2];
+ u8 i_fc[2];
+ u8 i_dur[2];
+ u8 i_addr1[IEEE80211_ADDR_LEN];
+ u8 i_addr2[IEEE80211_ADDR_LEN];
+ u8 i_addr3[IEEE80211_ADDR_LEN];
+ u8 i_seq[2];
/* possibly followed by addr4[IEEE80211_ADDR_LEN]; */
/* see below */
} POSTPACK;
PREPACK struct ieee80211_qosframe {
- A_UINT8 i_fc[2];
- A_UINT8 i_dur[2];
- A_UINT8 i_addr1[IEEE80211_ADDR_LEN];
- A_UINT8 i_addr2[IEEE80211_ADDR_LEN];
- A_UINT8 i_addr3[IEEE80211_ADDR_LEN];
- A_UINT8 i_seq[2];
- A_UINT8 i_qos[2];
+ u8 i_fc[2];
+ u8 i_dur[2];
+ u8 i_addr1[IEEE80211_ADDR_LEN];
+ u8 i_addr2[IEEE80211_ADDR_LEN];
+ u8 i_addr3[IEEE80211_ADDR_LEN];
+ u8 i_seq[2];
+ u8 i_qos[2];
} POSTPACK;
#define IEEE80211_FC0_VERSION_MASK 0x03
* WMM/802.11e Tspec Element
*/
typedef PREPACK struct wmm_tspec_ie_t {
- A_UINT8 elementId;
- A_UINT8 len;
- A_UINT8 oui[3];
- A_UINT8 ouiType;
- A_UINT8 ouiSubType;
- A_UINT8 version;
+ u8 elementId;
+ u8 len;
+ u8 oui[3];
+ u8 ouiType;
+ u8 ouiSubType;
+ u8 version;
A_UINT16 tsInfo_info;
- A_UINT8 tsInfo_reserved;
+ u8 tsInfo_reserved;
A_UINT16 nominalMSDU;
A_UINT16 maxMSDU;
A_UINT32 minServiceInt;
#define IEEE80211_NODE_HASHSIZE 32
/* simple hash is enough for variation of macaddr */
#define IEEE80211_NODE_HASH(addr) \
- (((const A_UINT8 *)(addr))[IEEE80211_ADDR_LEN - 1] % \
+ (((const u8 *)(addr))[IEEE80211_ADDR_LEN - 1] % \
IEEE80211_NODE_HASHSIZE)
/*
A_UINT32 nt_scangen; /* gen# for timeout scan */
#ifdef THREAD_X
A_TIMER nt_inact_timer;
- A_UINT8 isTimerArmed; /* is the node timer armed */
+ u8 isTimerArmed; /* is the node timer armed */
#endif
A_UINT32 nt_nodeAge; /* node aging time */
#ifdef OS_ROAM_MANAGEMENT
#endif
static bss_t * _ieee80211_find_node (struct ieee80211_node_table *nt,
- const A_UINT8 *macaddr);
+ const u8 *macaddr);
bss_t *
wlan_node_alloc(struct ieee80211_node_table *nt, int wh_size)
void
wlan_setup_node(struct ieee80211_node_table *nt, bss_t *ni,
- const A_UINT8 *macaddr)
+ const u8 *macaddr)
{
int hash;
A_UINT32 timeoutValue = 0;
static bss_t *
_ieee80211_find_node(struct ieee80211_node_table *nt,
- const A_UINT8 *macaddr)
+ const u8 *macaddr)
{
bss_t *ni;
int hash;
}
bss_t *
-wlan_find_node(struct ieee80211_node_table *nt, const A_UINT8 *macaddr)
+wlan_find_node(struct ieee80211_node_table *nt, const u8 *macaddr)
{
bss_t *ni;
{
#ifdef THREAD_X
bss_t *bss, *nextBss;
- A_UINT8 myBssid[IEEE80211_ADDR_LEN], reArmTimer = false;
+ u8 myBssid[IEEE80211_ADDR_LEN], reArmTimer = false;
wmi_get_current_bssid(nt->nt_wmip, myBssid);
}
#else
bss_t *bss, *nextBss;
- A_UINT8 myBssid[IEEE80211_ADDR_LEN];
+ u8 myBssid[IEEE80211_ADDR_LEN];
A_UINT32 timeoutValue = 0;
A_UINT32 now = A_GET_MS(0);
timeoutValue = nt->nt_nodeAge;
{
struct ieee80211_node_table *nt = (struct ieee80211_node_table *)arg;
bss_t *bss, *nextBss;
- A_UINT8 myBssid[IEEE80211_ADDR_LEN], reArmTimer = false;
+ u8 myBssid[IEEE80211_ADDR_LEN], reArmTimer = false;
A_UINT32 timeoutValue = 0;
timeoutValue = nt->nt_nodeAge;
}
bss_t *
-wlan_node_remove(struct ieee80211_node_table *nt, A_UINT8 *bssid)
+wlan_node_remove(struct ieee80211_node_table *nt, u8 *bssid)
{
bss_t *bss, *nextBss;
/* unaligned little endian access */
#define LE_READ_2(p) \
((A_UINT16) \
- ((((A_UINT8 *)(p))[0] ) | (((A_UINT8 *)(p))[1] << 8)))
+ ((((u8 *)(p))[0] ) | (((u8 *)(p))[1] << 8)))
#define LE_READ_4(p) \
((A_UINT32) \
- ((((A_UINT8 *)(p))[0] ) | (((A_UINT8 *)(p))[1] << 8) | \
- (((A_UINT8 *)(p))[2] << 16) | (((A_UINT8 *)(p))[3] << 24)))
+ ((((u8 *)(p))[0] ) | (((u8 *)(p))[1] << 8) | \
+ (((u8 *)(p))[2] << 16) | (((u8 *)(p))[3] << 24)))
static int __inline
-iswpaoui(const A_UINT8 *frm)
+iswpaoui(const u8 *frm)
{
return frm[1] > 3 && LE_READ_4(frm+2) == ((WPA_OUI_TYPE<<24)|WPA_OUI);
}
static int __inline
-iswmmoui(const A_UINT8 *frm)
+iswmmoui(const u8 *frm)
{
return frm[1] > 3 && LE_READ_4(frm+2) == ((WMM_OUI_TYPE<<24)|WMM_OUI);
}
/* unused functions for now */
#if 0
static int __inline
-iswmmparam(const A_UINT8 *frm)
+iswmmparam(const u8 *frm)
{
return frm[1] > 5 && frm[6] == WMM_PARAM_OUI_SUBTYPE;
}
static int __inline
-iswmminfo(const A_UINT8 *frm)
+iswmminfo(const u8 *frm)
{
return frm[1] > 5 && frm[6] == WMM_INFO_OUI_SUBTYPE;
}
#endif
static int __inline
-isatherosoui(const A_UINT8 *frm)
+isatherosoui(const u8 *frm)
{
return frm[1] > 3 && LE_READ_4(frm+2) == ((ATH_OUI_TYPE<<24)|ATH_OUI);
}
static int __inline
-iswscoui(const A_UINT8 *frm)
+iswscoui(const u8 *frm)
{
return frm[1] > 3 && LE_READ_4(frm+2) == ((0x04<<24)|WPA_OUI);
}
int
-wlan_parse_beacon(A_UINT8 *buf, int framelen, struct ieee80211_common_ie *cie)
+wlan_parse_beacon(u8 *buf, int framelen, struct ieee80211_common_ie *cie)
{
- A_UINT8 *frm, *efrm;
- A_UINT8 elemid_ssid = false;
+ u8 *frm, *efrm;
+ u8 elemid_ssid = false;
frm = buf;
- efrm = (A_UINT8 *) (frm + framelen);
+ efrm = (u8 *) (frm + framelen);
/*
* beacon/probe response frame format
#define A_DPRINTF AR_DEBUG_PRINTF
#endif
-static int wmi_ready_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+static int wmi_ready_event_rx(struct wmi_t *wmip, u8 *datap, int len);
-static int wmi_connect_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_connect_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_disconnect_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_disconnect_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_tkip_micerr_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_tkip_micerr_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_bssInfo_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_bssInfo_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_opt_frame_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_opt_frame_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_pstream_timeout_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_pstream_timeout_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
static int wmi_sync_point(struct wmi_t *wmip);
-static int wmi_bitrate_reply_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_bitrate_reply_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_ratemask_reply_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_ratemask_reply_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_channelList_reply_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_channelList_reply_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_regDomain_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_regDomain_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_txPwr_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_neighborReport_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_txPwr_reply_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_neighborReport_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_dset_open_req_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_dset_open_req_rx(struct wmi_t *wmip, u8 *datap,
int len);
#ifdef CONFIG_HOST_DSET_SUPPORT
-static int wmi_dset_close_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_dset_data_req_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_dset_close_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_dset_data_req_rx(struct wmi_t *wmip, u8 *datap,
int len);
#endif /* CONFIG_HOST_DSET_SUPPORT */
-static int wmi_scanComplete_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_scanComplete_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_errorEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_statsEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_rssiThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_hbChallengeResp_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_reportErrorEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_cac_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_channel_change_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_roam_tbl_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_errorEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_statsEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_rssiThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_hbChallengeResp_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_reportErrorEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_cac_event_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_channel_change_event_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_roam_tbl_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_roam_data_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_roam_data_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_get_wow_list_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_get_wow_list_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
static int
-wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len);
+wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len);
static int
-wmi_set_params_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len);
+wmi_set_params_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len);
static int
-wmi_acm_reject_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len);
+wmi_acm_reject_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len);
#ifdef CONFIG_HOST_GPIO_SUPPORT
-static int wmi_gpio_intr_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_gpio_data_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_gpio_ack_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+static int wmi_gpio_intr_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_gpio_data_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_gpio_ack_rx(struct wmi_t *wmip, u8 *datap, int len);
#endif /* CONFIG_HOST_GPIO_SUPPORT */
#ifdef CONFIG_HOST_TCMD_SUPPORT
static int
-wmi_tcmd_test_report_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+wmi_tcmd_test_report_rx(struct wmi_t *wmip, u8 *datap, int len);
#endif
static int
-wmi_txRetryErrEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+wmi_txRetryErrEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
static int
-wmi_snrThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+wmi_snrThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
static int
-wmi_lqThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+wmi_lqThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
static bool
wmi_is_bitrate_index_valid(struct wmi_t *wmip, A_INT32 rateIndex);
static int
-wmi_aplistEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+wmi_aplistEvent_rx(struct wmi_t *wmip, u8 *datap, int len);
static int
-wmi_dbglog_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+wmi_dbglog_event_rx(struct wmi_t *wmip, u8 *datap, int len);
-static int wmi_keepalive_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+static int wmi_keepalive_reply_rx(struct wmi_t *wmip, u8 *datap, int len);
int wmi_cmd_send_xtnd(struct wmi_t *wmip, void *osbuf, WMIX_COMMAND_ID cmdId,
WMI_SYNC_FLAG syncflag);
-A_UINT8 ar6000_get_upper_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh, A_UINT32 size);
-A_UINT8 ar6000_get_lower_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh, A_UINT32 size);
+u8 ar6000_get_upper_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh, A_UINT32 size);
+u8 ar6000_get_lower_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh, A_UINT32 size);
void wmi_cache_configure_rssithreshold(struct wmi_t *wmip, WMI_RSSI_THRESHOLD_PARAMS_CMD *rssiCmd);
void wmi_cache_configure_snrthreshold(struct wmi_t *wmip, WMI_SNR_THRESHOLD_PARAMS_CMD *snrCmd);
WMI_SNR_THRESHOLD_PARAMS_CMD *snrCmd);
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
static int
-wmi_prof_count_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+wmi_prof_count_rx(struct wmi_t *wmip, u8 *datap, int len);
#endif /* CONFIG_TARGET_PROFILE_SUPPORT */
-static int wmi_pspoll_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_pspoll_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_dtimexpiry_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_dtimexpiry_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
-static int wmi_peer_node_event_rx (struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_peer_node_event_rx (struct wmi_t *wmip, u8 *datap,
int len);
#ifdef ATH_AR6K_11N_SUPPORT
-static int wmi_addba_req_event_rx(struct wmi_t *, A_UINT8 *, int);
-static int wmi_addba_resp_event_rx(struct wmi_t *, A_UINT8 *, int);
-static int wmi_delba_req_event_rx(struct wmi_t *, A_UINT8 *, int);
-static int wmi_btcoex_config_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
-static int wmi_btcoex_stats_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
+static int wmi_addba_req_event_rx(struct wmi_t *, u8 *, int);
+static int wmi_addba_resp_event_rx(struct wmi_t *, u8 *, int);
+static int wmi_delba_req_event_rx(struct wmi_t *, u8 *, int);
+static int wmi_btcoex_config_event_rx(struct wmi_t *wmip, u8 *datap, int len);
+static int wmi_btcoex_stats_event_rx(struct wmi_t *wmip, u8 *datap, int len);
#endif
-static int wmi_hci_event_rx(struct wmi_t *, A_UINT8 *, int);
+static int wmi_hci_event_rx(struct wmi_t *, u8 *, int);
#ifdef WAPI_ENABLE
-static int wmi_wapi_rekey_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
+static int wmi_wapi_rekey_event_rx(struct wmi_t *wmip, u8 *datap,
int len);
#endif
#define MAX_NUMBER_OF_SUPPORT_RATES (MODE_GHT20_SUPPORT_RATE_STOP + 1)
/* 802.1d to AC mapping. Refer pg 57 of WMM-test-plan-v1.2 */
-const A_UINT8 up_to_ac[]= {
+const u8 up_to_ac[]= {
WMM_AC_BE,
WMM_AC_BK,
WMM_AC_BK,
/* This stuff is used when we want a simple layer-3 visibility */
typedef PREPACK struct _iphdr {
- A_UINT8 ip_ver_hdrlen; /* version and hdr length */
- A_UINT8 ip_tos; /* type of service */
+ u8 ip_ver_hdrlen; /* version and hdr length */
+ u8 ip_tos; /* type of service */
A_UINT16 ip_len; /* total length */
A_UINT16 ip_id; /* identification */
A_INT16 ip_off; /* fragment offset field */
#define IP_DF 0x4000 /* dont fragment flag */
#define IP_MF 0x2000 /* more fragments flag */
#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
- A_UINT8 ip_ttl; /* time to live */
- A_UINT8 ip_p; /* protocol */
+ u8 ip_ttl; /* time to live */
+ u8 ip_p; /* protocol */
A_UINT16 ip_sum; /* checksum */
- A_UINT8 ip_src[4]; /* source and dest address */
- A_UINT8 ip_dst[4];
+ u8 ip_src[4]; /* source and dest address */
+ u8 ip_dst[4];
} POSTPACK iphdr;
#include "athendpack.h"
void
wmi_qos_state_init(struct wmi_t *wmip)
{
- A_UINT8 i;
+ u8 i;
if (wmip == NULL) {
return;
int
wmi_dix_2_dot3(struct wmi_t *wmip, void *osbuf)
{
- A_UINT8 *datap;
+ u8 *datap;
A_UINT16 typeorlen;
ATH_MAC_HDR macHdr;
ATH_LLC_SNAP_HDR *llcHdr;
return (A_OK);
}
-int wmi_meta_add(struct wmi_t *wmip, void *osbuf, A_UINT8 *pVersion,void *pTxMetaS)
+int wmi_meta_add(struct wmi_t *wmip, void *osbuf, u8 *pVersion,void *pTxMetaS)
{
switch(*pVersion){
case 0:
/* Adds a WMI data header */
int
-wmi_data_hdr_add(struct wmi_t *wmip, void *osbuf, A_UINT8 msgType, bool bMoreData,
- WMI_DATA_HDR_DATA_TYPE data_type,A_UINT8 metaVersion, void *pTxMetaS)
+wmi_data_hdr_add(struct wmi_t *wmip, void *osbuf, u8 msgType, bool bMoreData,
+ WMI_DATA_HDR_DATA_TYPE data_type,u8 metaVersion, void *pTxMetaS)
{
WMI_DATA_HDR *dtHdr;
-// A_UINT8 metaVersion = 0;
+// u8 metaVersion = 0;
int status;
A_ASSERT(osbuf != NULL);
}
-A_UINT8 wmi_implicit_create_pstream(struct wmi_t *wmip, void *osbuf, A_UINT32 layer2Priority, bool wmmEnabled)
+u8 wmi_implicit_create_pstream(struct wmi_t *wmip, void *osbuf, A_UINT32 layer2Priority, bool wmmEnabled)
{
- A_UINT8 *datap;
- A_UINT8 trafficClass = WMM_AC_BE;
+ u8 *datap;
+ u8 trafficClass = WMM_AC_BE;
A_UINT16 ipType = IP_ETHERTYPE;
WMI_DATA_HDR *dtHdr;
- A_UINT8 streamExists = 0;
- A_UINT8 userPriority;
+ u8 streamExists = 0;
+ u8 userPriority;
A_UINT32 hdrsize, metasize;
ATH_LLC_SNAP_HDR *llcHdr;
{
/* Extract the endpoint info from the TOS field in the IP header */
- userPriority = wmi_determine_userPriority (((A_UINT8 *)llcHdr) + sizeof(ATH_LLC_SNAP_HDR),layer2Priority);
+ userPriority = wmi_determine_userPriority (((u8 *)llcHdr) + sizeof(ATH_LLC_SNAP_HDR),layer2Priority);
}
else
{
int
wmi_dot11_hdr_add (struct wmi_t *wmip, void *osbuf, NETWORK_TYPE mode)
{
- A_UINT8 *datap;
+ u8 *datap;
A_UINT16 typeorlen;
ATH_MAC_HDR macHdr;
ATH_LLC_SNAP_HDR *llcHdr;
int
wmi_dot11_hdr_remove(struct wmi_t *wmip, void *osbuf)
{
- A_UINT8 *datap;
+ u8 *datap;
struct ieee80211_frame *pwh,wh;
- A_UINT8 type,subtype;
+ u8 type,subtype;
ATH_LLC_SNAP_HDR *llcHdr;
ATH_MAC_HDR macHdr;
A_UINT32 hdrsize;
type = pwh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
subtype = pwh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
- A_MEMCPY((A_UINT8 *)&wh, datap, sizeof(struct ieee80211_frame));
+ A_MEMCPY((u8 *)&wh, datap, sizeof(struct ieee80211_frame));
/* strip off the 802.11 hdr*/
if (subtype == IEEE80211_FC0_SUBTYPE_QOS) {
int
wmi_dot3_2_dix(void *osbuf)
{
- A_UINT8 *datap;
+ u8 *datap;
ATH_MAC_HDR macHdr;
ATH_LLC_SNAP_HDR *llcHdr;
{
WMIX_CMD_HDR *cmd;
A_UINT16 id;
- A_UINT8 *datap;
+ u8 *datap;
A_UINT32 len;
int status = A_OK;
{
WMI_CMD_HDR *cmd;
A_UINT16 id;
- A_UINT8 *datap;
+ u8 *datap;
A_UINT32 len, i, loggingReq;
int status = A_OK;
#endif
static int
-wmi_ready_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_ready_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_READY_EVENT *ev = (WMI_READY_EVENT *)datap;
#define LE_READ_4(p) \
((A_UINT32) \
- ((((A_UINT8 *)(p))[0] ) | (((A_UINT8 *)(p))[1] << 8) | \
- (((A_UINT8 *)(p))[2] << 16) | (((A_UINT8 *)(p))[3] << 24)))
+ ((((u8 *)(p))[0] ) | (((u8 *)(p))[1] << 8) | \
+ (((u8 *)(p))[2] << 16) | (((u8 *)(p))[3] << 24)))
static int __inline
-iswmmoui(const A_UINT8 *frm)
+iswmmoui(const u8 *frm)
{
return frm[1] > 3 && LE_READ_4(frm+2) == ((WMM_OUI_TYPE<<24)|WMM_OUI);
}
static int __inline
-iswmmparam(const A_UINT8 *frm)
+iswmmparam(const u8 *frm)
{
return frm[1] > 5 && frm[6] == WMM_PARAM_OUI_SUBTYPE;
}
static int
-wmi_connect_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_connect_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_CONNECT_EVENT *ev;
- A_UINT8 *pie,*peie;
+ u8 *pie,*peie;
if (len < sizeof(WMI_CONNECT_EVENT))
{
}
static int
-wmi_regDomain_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_regDomain_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_REG_DOMAIN_EVENT *ev;
}
static int
-wmi_neighborReport_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_neighborReport_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_NEIGHBOR_REPORT_EVENT *ev;
int numAps;
}
static int
-wmi_disconnect_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_disconnect_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_DISCONNECT_EVENT *ev;
wmip->wmi_traffic_class = 100;
}
static int
-wmi_peer_node_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_peer_node_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_PEER_NODE_EVENT *ev;
}
static int
-wmi_tkip_micerr_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_tkip_micerr_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_TKIP_MICERR_EVENT *ev;
}
static int
-wmi_bssInfo_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_bssInfo_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
bss_t *bss = NULL;
WMI_BSS_INFO_HDR *bih;
- A_UINT8 *buf;
+ u8 *buf;
A_UINT32 nodeCachingAllowed = 1;
A_UCHAR cached_ssid_len = 0;
A_UCHAR cached_ssid_buf[IEEE80211_NWID_LEN] = {0};
- A_UINT8 beacon_ssid_len = 0;
+ u8 beacon_ssid_len = 0;
if (len <= sizeof(WMI_BSS_INFO_HDR)) {
return A_EINVAL;
(0 != cached_ssid_len) &&
(0 == beacon_ssid_len || (beacon_ssid_len && 0 == buf[SSID_IE_LEN_INDEX + 1])))
{
- A_UINT8 *ni_buf = bss->ni_buf;
+ u8 *ni_buf = bss->ni_buf;
int buf_len = len;
/* copy the first 14 bytes such as
}
static int
-wmi_opt_frame_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_opt_frame_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
bss_t *bss;
WMI_OPT_RX_INFO_HDR *bih;
- A_UINT8 *buf;
+ u8 *buf;
if (len <= sizeof(WMI_OPT_RX_INFO_HDR)) {
return A_EINVAL;
* at the target
*/
static int
-wmi_pstream_timeout_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_pstream_timeout_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_PSTREAM_TIMEOUT_EVENT *ev;
}
static int
-wmi_bitrate_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_bitrate_reply_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_BIT_RATE_REPLY *reply;
A_INT32 rate;
}
static int
-wmi_ratemask_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_ratemask_reply_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_FIX_RATES_REPLY *reply;
}
static int
-wmi_channelList_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_channelList_reply_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_CHANNEL_LIST_REPLY *reply;
}
static int
-wmi_txPwr_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_txPwr_reply_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_TX_PWR_REPLY *reply;
return A_OK;
}
static int
-wmi_keepalive_reply_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_keepalive_reply_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_GET_KEEPALIVE_CMD *reply;
static int
-wmi_dset_open_req_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_dset_open_req_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMIX_DSETOPENREQ_EVENT *dsetopenreq;
#ifdef CONFIG_HOST_DSET_SUPPORT
static int
-wmi_dset_close_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_dset_close_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMIX_DSETCLOSE_EVENT *dsetclose;
}
static int
-wmi_dset_data_req_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_dset_data_req_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMIX_DSETDATAREQ_EVENT *dsetdatareq;
#endif /* CONFIG_HOST_DSET_SUPPORT */
static int
-wmi_scanComplete_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_scanComplete_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_SCAN_COMPLETE_EVENT *ev;
* A reset is recommended.
*/
static int
-wmi_errorEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_errorEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_CMD_ERROR_EVENT *ev;
static int
-wmi_statsEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_statsEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
{
A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
}
static int
-wmi_rssiThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_rssiThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_RSSI_THRESHOLD_EVENT *reply;
WMI_RSSI_THRESHOLD_VAL newThreshold;
WMI_RSSI_THRESHOLD_PARAMS_CMD cmd;
SQ_THRESHOLD_PARAMS *sq_thresh =
&wmip->wmi_SqThresholdParams[SIGNAL_QUALITY_METRICS_RSSI];
- A_UINT8 upper_rssi_threshold, lower_rssi_threshold;
+ u8 upper_rssi_threshold, lower_rssi_threshold;
A_INT16 rssi;
if (len < sizeof(*reply)) {
static int
-wmi_reportErrorEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_reportErrorEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_TARGET_ERROR_REPORT_EVENT *reply;
}
static int
-wmi_cac_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_cac_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_CAC_EVENT *reply;
WMM_TSPEC_IE *tspec_ie;
(tspec_ie->tsInfo_info >> TSPEC_TSID_S) & TSPEC_TSID_MASK);
}
else if (reply->cac_indication == CAC_INDICATION_NO_RESP) {
- A_UINT8 i;
+ u8 i;
/* following assumes that there is only one outstanding ADDTS request
when this event is received */
* for delete qos stream from AP
*/
else if (reply->cac_indication == CAC_INDICATION_DELETE) {
- A_UINT8 tsid = 0;
+ u8 tsid = 0;
tspec_ie = (WMM_TSPEC_IE *) &(reply->tspecSuggestion);
tsid= ((tspec_ie->tsInfo_info >> TSPEC_TSID_S) & TSPEC_TSID_MASK);
}
static int
-wmi_channel_change_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_channel_change_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_CHANNEL_CHANGE_EVENT *reply;
}
static int
-wmi_hbChallengeResp_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_hbChallengeResp_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMIX_HB_CHALLENGE_RESP_EVENT *reply;
}
static int
-wmi_roam_tbl_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_roam_tbl_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_TARGET_ROAM_TBL *reply;
}
static int
-wmi_roam_data_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_roam_data_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_TARGET_ROAM_DATA *reply;
}
static int
-wmi_txRetryErrEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_txRetryErrEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
{
if (len < sizeof(WMI_TX_RETRY_ERR_EVENT)) {
return A_EINVAL;
}
static int
-wmi_snrThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_snrThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_SNR_THRESHOLD_EVENT *reply;
SQ_THRESHOLD_PARAMS *sq_thresh =
&wmip->wmi_SqThresholdParams[SIGNAL_QUALITY_METRICS_SNR];
WMI_SNR_THRESHOLD_VAL newThreshold;
WMI_SNR_THRESHOLD_PARAMS_CMD cmd;
- A_UINT8 upper_snr_threshold, lower_snr_threshold;
+ u8 upper_snr_threshold, lower_snr_threshold;
A_INT16 snr;
if (len < sizeof(*reply)) {
}
static int
-wmi_lqThresholdEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_lqThresholdEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_LQ_THRESHOLD_EVENT *reply;
}
static int
-wmi_aplistEvent_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_aplistEvent_rx(struct wmi_t *wmip, u8 *datap, int len)
{
A_UINT16 ap_info_entry_size;
WMI_APLIST_EVENT *ev = (WMI_APLIST_EVENT *)datap;
WMI_AP_INFO_V1 *ap_info_v1;
- A_UINT8 i;
+ u8 i;
if (len < sizeof(WMI_APLIST_EVENT)) {
return A_EINVAL;
}
static int
-wmi_dbglog_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_dbglog_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
A_UINT32 dropped;
#ifdef CONFIG_HOST_GPIO_SUPPORT
static int
-wmi_gpio_intr_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_gpio_intr_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMIX_GPIO_INTR_EVENT *gpio_intr = (WMIX_GPIO_INTR_EVENT *)datap;
}
static int
-wmi_gpio_data_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_gpio_data_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMIX_GPIO_DATA_EVENT *gpio_data = (WMIX_GPIO_DATA_EVENT *)datap;
}
static int
-wmi_gpio_ack_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_gpio_ack_rx(struct wmi_t *wmip, u8 *datap, int len)
{
A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
int
wmi_connect_cmd(struct wmi_t *wmip, NETWORK_TYPE netType,
DOT11_AUTH_MODE dot11AuthMode, AUTH_MODE authMode,
- CRYPTO_TYPE pairwiseCrypto, A_UINT8 pairwiseCryptoLen,
- CRYPTO_TYPE groupCrypto, A_UINT8 groupCryptoLen,
+ CRYPTO_TYPE pairwiseCrypto, u8 pairwiseCryptoLen,
+ CRYPTO_TYPE groupCrypto, u8 groupCryptoLen,
int ssidLength, A_UCHAR *ssid,
- A_UINT8 *bssid, A_UINT16 channel, A_UINT32 ctrl_flags)
+ u8 *bssid, A_UINT16 channel, A_UINT32 ctrl_flags)
{
void *osbuf;
WMI_CONNECT_CMD *cc;
}
int
-wmi_reconnect_cmd(struct wmi_t *wmip, A_UINT8 *bssid, A_UINT16 channel)
+wmi_reconnect_cmd(struct wmi_t *wmip, u8 *bssid, A_UINT16 channel)
{
void *osbuf;
WMI_RECONNECT_CMD *cc;
A_UINT16 fg_end_sec, A_UINT16 bg_sec,
A_UINT16 minact_chdw_msec, A_UINT16 maxact_chdw_msec,
A_UINT16 pas_chdw_msec,
- A_UINT8 shScanRatio, A_UINT8 scanCtrlFlags,
+ u8 shScanRatio, u8 scanCtrlFlags,
A_UINT32 max_dfsch_act_time, A_UINT16 maxact_scan_per_ssid)
{
void *osbuf;
}
int
-wmi_bssfilter_cmd(struct wmi_t *wmip, A_UINT8 filter, A_UINT32 ieMask)
+wmi_bssfilter_cmd(struct wmi_t *wmip, u8 filter, A_UINT32 ieMask)
{
void *osbuf;
WMI_BSS_FILTER_CMD *cmd;
}
int
-wmi_probedSsid_cmd(struct wmi_t *wmip, A_UINT8 index, A_UINT8 flag,
- A_UINT8 ssidLength, A_UCHAR *ssid)
+wmi_probedSsid_cmd(struct wmi_t *wmip, u8 index, u8 flag,
+ u8 ssidLength, A_UCHAR *ssid)
{
void *osbuf;
WMI_PROBED_SSID_CMD *cmd;
}
int
-wmi_associnfo_cmd(struct wmi_t *wmip, A_UINT8 ieType,
- A_UINT8 ieLen, A_UINT8 *ieInfo)
+wmi_associnfo_cmd(struct wmi_t *wmip, u8 ieType,
+ u8 ieLen, u8 *ieInfo)
{
void *osbuf;
WMI_SET_ASSOC_INFO_CMD *cmd;
}
int
-wmi_powermode_cmd(struct wmi_t *wmip, A_UINT8 powerMode)
+wmi_powermode_cmd(struct wmi_t *wmip, u8 powerMode)
{
void *osbuf;
WMI_POWER_MODE_CMD *cmd;
}
int
-wmi_ibsspmcaps_cmd(struct wmi_t *wmip, A_UINT8 pmEnable, A_UINT8 ttl,
+wmi_ibsspmcaps_cmd(struct wmi_t *wmip, u8 pmEnable, u8 ttl,
A_UINT16 atim_windows, A_UINT16 timeout_value)
{
void *osbuf;
}
int
-wmi_apps_cmd(struct wmi_t *wmip, A_UINT8 psType, A_UINT32 idle_time,
- A_UINT32 ps_period, A_UINT8 sleep_period)
+wmi_apps_cmd(struct wmi_t *wmip, u8 psType, A_UINT32 idle_time,
+ A_UINT32 ps_period, u8 sleep_period)
{
void *osbuf;
WMI_AP_PS_CMD *cmd;
}
int
-wmi_disctimeout_cmd(struct wmi_t *wmip, A_UINT8 timeout)
+wmi_disctimeout_cmd(struct wmi_t *wmip, u8 timeout)
{
void *osbuf;
WMI_DISC_TIMEOUT_CMD *cmd;
}
int
-wmi_addKey_cmd(struct wmi_t *wmip, A_UINT8 keyIndex, CRYPTO_TYPE keyType,
- A_UINT8 keyUsage, A_UINT8 keyLength, A_UINT8 *keyRSC,
- A_UINT8 *keyMaterial, A_UINT8 key_op_ctrl, A_UINT8 *macAddr,
+wmi_addKey_cmd(struct wmi_t *wmip, u8 keyIndex, CRYPTO_TYPE keyType,
+ u8 keyUsage, u8 keyLength, u8 *keyRSC,
+ u8 *keyMaterial, u8 key_op_ctrl, u8 *macAddr,
WMI_SYNC_FLAG sync_flag)
{
void *osbuf;
}
int
-wmi_add_krk_cmd(struct wmi_t *wmip, A_UINT8 *krk)
+wmi_add_krk_cmd(struct wmi_t *wmip, u8 *krk)
{
void *osbuf;
WMI_ADD_KRK_CMD *cmd;
}
int
-wmi_deleteKey_cmd(struct wmi_t *wmip, A_UINT8 keyIndex)
+wmi_deleteKey_cmd(struct wmi_t *wmip, u8 keyIndex)
{
void *osbuf;
WMI_DELETE_CIPHER_KEY_CMD *cmd;
}
int
-wmi_setPmkid_cmd(struct wmi_t *wmip, A_UINT8 *bssid, A_UINT8 *pmkId,
+wmi_setPmkid_cmd(struct wmi_t *wmip, u8 *bssid, u8 *pmkId,
bool set)
{
void *osbuf;
void *osbuf;
WMI_SET_PMKID_LIST_CMD *cmd;
A_UINT16 cmdLen;
- A_UINT8 i;
+ u8 i;
cmdLen = sizeof(pmkInfo->numPMKID) +
pmkInfo->numPMKID * sizeof(WMI_PMKID);
}
typedef struct _WMI_DATA_SYNC_BUFS {
- A_UINT8 trafficClass;
+ u8 trafficClass;
void *osbuf;
}WMI_DATA_SYNC_BUFS;
void *cmd_osbuf;
WMI_SYNC_CMD *cmd;
WMI_DATA_SYNC_BUFS dataSyncBufs[WMM_NUM_AC];
- A_UINT8 i,numPriStreams=0;
+ u8 i,numPriStreams=0;
int status = A_OK;
A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
{
void *osbuf;
WMI_CREATE_PSTREAM_CMD *cmd;
- A_UINT8 fatPipeExistsForAC=0;
+ u8 fatPipeExistsForAC=0;
A_INT32 minimalPHY = 0;
A_INT32 nominalPHY = 0;
}
int
-wmi_delete_pstream_cmd(struct wmi_t *wmip, A_UINT8 trafficClass, A_UINT8 tsid)
+wmi_delete_pstream_cmd(struct wmi_t *wmip, u8 trafficClass, u8 tsid)
{
void *osbuf;
WMI_DELETE_PSTREAM_CMD *cmd;
}
int
-wmi_set_framerate_cmd(struct wmi_t *wmip, A_UINT8 bEnable, A_UINT8 type, A_UINT8 subType, A_UINT16 rateMask)
+wmi_set_framerate_cmd(struct wmi_t *wmip, u8 bEnable, u8 type, u8 subType, A_UINT16 rateMask)
{
void *osbuf;
WMI_FRAME_RATES_CMD *cmd;
- A_UINT8 frameType;
+ u8 frameType;
A_DPRINTF(DBG_WMI,
(DBGFMT " type %02X, subType %02X, rateMask %04x\n", DBGARG, type, subType, rateMask));
cmd = (WMI_FRAME_RATES_CMD *)(A_NETBUF_DATA(osbuf));
A_MEMZERO(cmd, sizeof(*cmd));
- frameType = (A_UINT8)((subType << 4) | type);
+ frameType = (u8)((subType << 4) | type);
cmd->bEnableMask = bEnable;
cmd->frameType = frameType;
* array should correspond to numChan entries.
*/
int
-wmi_set_channelParams_cmd(struct wmi_t *wmip, A_UINT8 scanParam,
+wmi_set_channelParams_cmd(struct wmi_t *wmip, u8 scanParam,
WMI_PHY_MODE mode, A_INT8 numChan,
A_UINT16 *channelList)
{
WMI_SET_IP_CMD *cmd;
/* Multicast address are not valid */
- if((*((A_UINT8*)&ipCmd->ips[0]) >= 0xE0) ||
- (*((A_UINT8*)&ipCmd->ips[1]) >= 0xE0)) {
+ if((*((u8 *)&ipCmd->ips[0]) >= 0xE0) ||
+ (*((u8 *)&ipCmd->ips[1]) >= 0xE0)) {
return A_EINVAL;
}
A_INT8 size;
WMI_SET_HOST_SLEEP_MODE_CMD *cmd;
A_UINT16 activeTsids=0;
- A_UINT8 streamExists=0;
- A_UINT8 i;
+ u8 streamExists=0;
+ u8 i;
if( hostModeCmd->awake == hostModeCmd->asleep) {
return A_EINVAL;
}
static int
-wmi_get_wow_list_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_get_wow_list_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_GET_WOW_LIST_REPLY *reply;
int wmi_add_wow_pattern_cmd(struct wmi_t *wmip,
WMI_ADD_WOW_PATTERN_CMD *addWowCmd,
- A_UINT8* pattern, A_UINT8* mask,
- A_UINT8 pattern_size)
+ u8 *pattern, u8 *mask,
+ u8 pattern_size)
{
void *osbuf;
A_INT8 size;
WMI_ADD_WOW_PATTERN_CMD *cmd;
- A_UINT8 *filter_mask = NULL;
+ u8 *filter_mask = NULL;
size = sizeof (*cmd);
- size += ((2 * addWowCmd->filter_size)* sizeof(A_UINT8));
+ size += ((2 * addWowCmd->filter_size)* sizeof(u8));
osbuf = A_NETBUF_ALLOC(size);
if (osbuf == NULL) {
return A_NO_MEMORY;
A_MEMCPY(cmd->filter, pattern, addWowCmd->filter_size);
- filter_mask = (A_UINT8*)(cmd->filter + cmd->filter_size);
+ filter_mask = (u8 *)(cmd->filter + cmd->filter_size);
A_MEMCPY(filter_mask, mask, addWowCmd->filter_size);
* event from the target which is used for the configuring the correct
* thresholds
*/
- snrCmd->thresholdAbove1_Val = (A_UINT8)sq_thresh->upper_threshold[0];
- snrCmd->thresholdBelow1_Val = (A_UINT8)sq_thresh->lower_threshold[0];
+ snrCmd->thresholdAbove1_Val = (u8)sq_thresh->upper_threshold[0];
+ snrCmd->thresholdBelow1_Val = (u8)sq_thresh->lower_threshold[0];
} else {
/*
* In case the user issues multiple times of snr_threshold_setting,
}
int
-wmi_addBadAp_cmd(struct wmi_t *wmip, A_UINT8 apIndex, A_UINT8 *bssid)
+wmi_addBadAp_cmd(struct wmi_t *wmip, u8 apIndex, u8 *bssid)
{
void *osbuf;
WMI_ADD_BAD_AP_CMD *cmd;
}
int
-wmi_deleteBadAp_cmd(struct wmi_t *wmip, A_UINT8 apIndex)
+wmi_deleteBadAp_cmd(struct wmi_t *wmip, u8 apIndex)
{
void *osbuf;
WMI_DELETE_BAD_AP_CMD *cmd;
}
int
-wmi_set_txPwr_cmd(struct wmi_t *wmip, A_UINT8 dbM)
+wmi_set_txPwr_cmd(struct wmi_t *wmip, u8 dbM)
{
void *osbuf;
WMI_SET_TX_PWR_CMD *cmd;
}
A_UINT16
-wmi_get_mapped_qos_queue(struct wmi_t *wmip, A_UINT8 trafficClass)
+wmi_get_mapped_qos_queue(struct wmi_t *wmip, u8 trafficClass)
{
A_UINT16 activeTsids=0;
}
int
-wmi_get_roam_data_cmd(struct wmi_t *wmip, A_UINT8 roamDataType)
+wmi_get_roam_data_cmd(struct wmi_t *wmip, u8 roamDataType)
{
void *osbuf;
- A_UINT32 size = sizeof(A_UINT8);
+ A_UINT32 size = sizeof(u8);
WMI_TARGET_ROAM_DATA *cmd;
osbuf = A_NETBUF_ALLOC(size); /* no payload */
int
wmi_set_roam_ctrl_cmd(struct wmi_t *wmip, WMI_SET_ROAM_CTRL_CMD *p,
- A_UINT8 size)
+ u8 size)
{
void *osbuf;
WMI_SET_ROAM_CTRL_CMD *cmd;
int
wmi_set_powersave_timers_cmd(struct wmi_t *wmip,
WMI_POWERSAVE_TIMERS_POLICY_CMD *pCmd,
- A_UINT8 size)
+ u8 size)
{
void *osbuf;
WMI_POWERSAVE_TIMERS_POLICY_CMD *cmd;
#endif /* CONFIG_HOST_GPIO_SUPPORT */
int
-wmi_set_access_params_cmd(struct wmi_t *wmip, A_UINT8 ac, A_UINT16 txop, A_UINT8 eCWmin,
- A_UINT8 eCWmax, A_UINT8 aifsn)
+wmi_set_access_params_cmd(struct wmi_t *wmip, u8 ac, A_UINT16 txop, u8 eCWmin,
+ u8 eCWmax, u8 aifsn)
{
void *osbuf;
WMI_SET_ACCESS_PARAMS_CMD *cmd;
}
int
-wmi_set_retry_limits_cmd(struct wmi_t *wmip, A_UINT8 frameType,
- A_UINT8 trafficClass, A_UINT8 maxRetries,
- A_UINT8 enableNotify)
+wmi_set_retry_limits_cmd(struct wmi_t *wmip, u8 frameType,
+ u8 trafficClass, u8 maxRetries,
+ u8 enableNotify)
{
void *osbuf;
WMI_SET_RETRY_LIMITS_CMD *cmd;
}
void
-wmi_get_current_bssid(struct wmi_t *wmip, A_UINT8 *bssid)
+wmi_get_current_bssid(struct wmi_t *wmip, u8 *bssid)
{
if (bssid != NULL) {
A_MEMCPY(bssid, wmip->wmi_bssid, ATH_MAC_LEN);
}
int
-wmi_set_opt_mode_cmd(struct wmi_t *wmip, A_UINT8 optMode)
+wmi_set_opt_mode_cmd(struct wmi_t *wmip, u8 optMode)
{
void *osbuf;
WMI_SET_OPT_MODE_CMD *cmd;
int
wmi_opt_tx_frame_cmd(struct wmi_t *wmip,
- A_UINT8 frmType,
- A_UINT8 *dstMacAddr,
- A_UINT8 *bssid,
+ u8 frmType,
+ u8 *dstMacAddr,
+ u8 *bssid,
A_UINT16 optIEDataLen,
- A_UINT8 *optIEData)
+ u8 *optIEData)
{
void *osbuf;
WMI_OPT_TX_FRAME_CMD *cmd;
cmd->frmType = frmType;
cmd->optIEDataLen = optIEDataLen;
- //cmd->optIEData = (A_UINT8 *)((int)cmd + sizeof(*cmd));
+ //cmd->optIEData = (u8 *)((int)cmd + sizeof(*cmd));
A_MEMCPY(cmd->bssid, bssid, sizeof(cmd->bssid));
A_MEMCPY(cmd->dstAddr, dstMacAddr, sizeof(cmd->dstAddr));
A_MEMCPY(&cmd->optIEData[0], optIEData, optIEDataLen);
int
-wmi_set_max_sp_len_cmd(struct wmi_t *wmip, A_UINT8 maxSPLen)
+wmi_set_max_sp_len_cmd(struct wmi_t *wmip, u8 maxSPLen)
{
void *osbuf;
WMI_SET_MAX_SP_LEN_CMD *cmd;
NO_SYNC_WMIFLAG));
}
-A_UINT8
-wmi_determine_userPriority(
- A_UINT8 *pkt,
+u8 wmi_determine_userPriority(
+ u8 *pkt,
A_UINT32 layer2Pri)
{
- A_UINT8 ipPri;
+ u8 ipPri;
iphdr *ipHdr = (iphdr *)pkt;
/* Determine IPTOS priority */
ipPri &= 0x7;
if ((layer2Pri & 0x7) > ipPri)
- return ((A_UINT8)layer2Pri & 0x7);
+ return ((u8)layer2Pri & 0x7);
else
return ipPri;
}
-A_UINT8
-convert_userPriority_to_trafficClass(A_UINT8 userPriority)
+u8 convert_userPriority_to_trafficClass(u8 userPriority)
{
return (up_to_ac[userPriority & 0x7]);
}
-A_UINT8
-wmi_get_power_mode_cmd(struct wmi_t *wmip)
+u8 wmi_get_power_mode_cmd(struct wmi_t *wmip)
{
return wmip->wmi_powerMode;
}
#ifdef CONFIG_HOST_TCMD_SUPPORT
static int
-wmi_tcmd_test_report_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_tcmd_test_report_rx(struct wmi_t *wmip, u8 *datap, int len)
{
A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
#endif /* CONFIG_HOST_TCMD_SUPPORT*/
int
-wmi_set_authmode_cmd(struct wmi_t *wmip, A_UINT8 mode)
+wmi_set_authmode_cmd(struct wmi_t *wmip, u8 mode)
{
void *osbuf;
WMI_SET_AUTH_MODE_CMD *cmd;
}
int
-wmi_set_reassocmode_cmd(struct wmi_t *wmip, A_UINT8 mode)
+wmi_set_reassocmode_cmd(struct wmi_t *wmip, u8 mode)
{
void *osbuf;
WMI_SET_REASSOC_MODE_CMD *cmd;
}
int
-wmi_set_lpreamble_cmd(struct wmi_t *wmip, A_UINT8 status, A_UINT8 preamblePolicy)
+wmi_set_lpreamble_cmd(struct wmi_t *wmip, u8 status, u8 preamblePolicy)
{
void *osbuf;
WMI_SET_LPREAMBLE_CMD *cmd;
}
int
-wmi_set_qos_supp_cmd(struct wmi_t *wmip, A_UINT8 status)
+wmi_set_qos_supp_cmd(struct wmi_t *wmip, u8 status)
{
void *osbuf;
WMI_SET_QOS_SUPP_CMD *cmd;
have different test command requirements from differnt manufacturers
*/
int
-wmi_test_cmd(struct wmi_t *wmip, A_UINT8 *buf, A_UINT32 len)
+wmi_test_cmd(struct wmi_t *wmip, u8 *buf, A_UINT32 len)
{
void *osbuf;
char *data;
#endif
int
-wmi_set_bt_status_cmd(struct wmi_t *wmip, A_UINT8 streamType, A_UINT8 status)
+wmi_set_bt_status_cmd(struct wmi_t *wmip, u8 streamType, u8 status)
{
void *osbuf;
WMI_SET_BT_STATUS_CMD *cmd;
NO_SYNC_WMIFLAG));
}
-A_UINT8
-wmi_get_keepalive_cmd(struct wmi_t *wmip)
+u8 wmi_get_keepalive_cmd(struct wmi_t *wmip)
{
return wmip->wmi_keepaliveInterval;
}
int
-wmi_set_keepalive_cmd(struct wmi_t *wmip, A_UINT8 keepaliveInterval)
+wmi_set_keepalive_cmd(struct wmi_t *wmip, u8 keepaliveInterval)
{
void *osbuf;
WMI_SET_KEEPALIVE_CMD *cmd;
int
-wmi_set_mcast_filter_cmd(struct wmi_t *wmip, A_UINT8 dot1, A_UINT8 dot2, A_UINT8 dot3, A_UINT8 dot4)
+wmi_set_mcast_filter_cmd(struct wmi_t *wmip, u8 dot1, u8 dot2, u8 dot3, u8 dot4)
{
void *osbuf;
WMI_SET_MCAST_FILTER_CMD *cmd;
int
-wmi_del_mcast_filter_cmd(struct wmi_t *wmip, A_UINT8 dot1, A_UINT8 dot2, A_UINT8 dot3, A_UINT8 dot4)
+wmi_del_mcast_filter_cmd(struct wmi_t *wmip, u8 dot1, u8 dot2, u8 dot3, u8 dot4)
{
void *osbuf;
WMI_SET_MCAST_FILTER_CMD *cmd;
}
int
-wmi_mcast_filter_cmd(struct wmi_t *wmip, A_UINT8 enable)
+wmi_mcast_filter_cmd(struct wmi_t *wmip, u8 enable)
{
void *osbuf;
WMI_MCAST_FILTER_CMD *cmd;
}
int
-wmi_set_appie_cmd(struct wmi_t *wmip, A_UINT8 mgmtFrmType, A_UINT8 ieLen,
- A_UINT8 *ieInfo)
+wmi_set_appie_cmd(struct wmi_t *wmip, u8 mgmtFrmType, u8 ieLen,
+ u8 *ieInfo)
{
void *osbuf;
WMI_SET_APPIE_CMD *cmd;
}
int
-wmi_set_halparam_cmd(struct wmi_t *wmip, A_UINT8 *cmd, A_UINT16 dataLen)
+wmi_set_halparam_cmd(struct wmi_t *wmip, u8 *cmd, A_UINT16 dataLen)
{
void *osbuf;
- A_UINT8 *data;
+ u8 *data;
osbuf = A_NETBUF_ALLOC(dataLen);
if (osbuf == NULL) {
}
bss_t *
-wmi_find_node(struct wmi_t *wmip, const A_UINT8 *macaddr)
+wmi_find_node(struct wmi_t *wmip, const u8 *macaddr)
{
bss_t *ni=NULL;
ni=wlan_find_node(&wmip->wmi_scan_table,macaddr);
}
void
-wmi_free_node(struct wmi_t *wmip, const A_UINT8 *macaddr)
+wmi_free_node(struct wmi_t *wmip, const u8 *macaddr)
{
bss_t *ni=NULL;
}
static int
-wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len)
+wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len)
{
WMI_PMKID_LIST_REPLY *reply;
A_UINT32 expected_len;
static int
-wmi_set_params_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len)
+wmi_set_params_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len)
{
WMI_SET_PARAMS_REPLY *reply;
static int
-wmi_acm_reject_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len)
+wmi_acm_reject_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len)
{
WMI_ACM_REJECT_EVENT *ev;
int
wmi_dset_data_reply(struct wmi_t *wmip,
A_UINT32 status,
- A_UINT8 *user_buf,
+ u8 *user_buf,
A_UINT32 length,
A_UINT32 targ_buf,
A_UINT32 targ_reply_fn,
/* Called to handle WMIX_PROF_CONT_EVENTID */
static int
-wmi_prof_count_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_prof_count_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMIX_PROF_COUNT_EVENT *prof_data = (WMIX_PROF_COUNT_EVENT *)datap;
}
#endif
-A_UINT8
-ar6000_get_upper_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh,
+u8 ar6000_get_upper_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh,
A_UINT32 size)
{
A_UINT32 index;
- A_UINT8 threshold = (A_UINT8)sq_thresh->upper_threshold[size - 1];
+ u8 threshold = (u8)sq_thresh->upper_threshold[size - 1];
/* The list is already in sorted order. Get the next lower value */
for (index = 0; index < size; index ++) {
if (rssi < sq_thresh->upper_threshold[index]) {
- threshold = (A_UINT8)sq_thresh->upper_threshold[index];
+ threshold = (u8)sq_thresh->upper_threshold[index];
break;
}
}
return threshold;
}
-A_UINT8
-ar6000_get_lower_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh,
+u8 ar6000_get_lower_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh,
A_UINT32 size)
{
A_UINT32 index;
- A_UINT8 threshold = (A_UINT8)sq_thresh->lower_threshold[size - 1];
+ u8 threshold = (u8)sq_thresh->lower_threshold[size - 1];
/* The list is already in sorted order. Get the next lower value */
for (index = 0; index < size; index ++) {
if (rssi > sq_thresh->lower_threshold[index]) {
- threshold = (A_UINT8)sq_thresh->lower_threshold[index];
+ threshold = (u8)sq_thresh->lower_threshold[index];
break;
}
}
NO_SYNC_WMIFLAG));
}
-bss_t *wmi_rm_current_bss (struct wmi_t *wmip, A_UINT8 *id)
+bss_t *wmi_rm_current_bss (struct wmi_t *wmip, u8 *id)
{
wmi_get_current_bssid (wmip, id);
return wlan_node_remove (&wmip->wmi_scan_table, id);
}
-int wmi_add_current_bss (struct wmi_t *wmip, A_UINT8 *id, bss_t *bss)
+int wmi_add_current_bss (struct wmi_t *wmip, u8 *id, bss_t *bss)
{
wlan_setup_node (&wmip->wmi_scan_table, bss, id);
return A_OK;
#ifdef ATH_AR6K_11N_SUPPORT
static int
-wmi_addba_req_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_addba_req_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_ADDBA_REQ_EVENT *cmd = (WMI_ADDBA_REQ_EVENT *)datap;
static int
-wmi_addba_resp_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_addba_resp_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_ADDBA_RESP_EVENT *cmd = (WMI_ADDBA_RESP_EVENT *)datap;
}
static int
-wmi_delba_req_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_delba_req_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_DELBA_EVENT *cmd = (WMI_DELBA_EVENT *)datap;
}
int
-wmi_btcoex_config_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_btcoex_config_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
int
-wmi_btcoex_stats_event_rx(struct wmi_t * wmip,A_UINT8 * datap,int len)
+wmi_btcoex_stats_event_rx(struct wmi_t * wmip,u8 *datap,int len)
{
A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
#endif
static int
-wmi_hci_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_hci_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_HCI_EVENT *cmd = (WMI_HCI_EVENT *)datap;
A_WMI_HCI_EVENT_EVT(wmip->wmi_devt, cmd);
* beacon. If it is enabled, ssid will be NULL in beacon.
*/
int
-wmi_ap_set_hidden_ssid(struct wmi_t *wmip, A_UINT8 hidden_ssid)
+wmi_ap_set_hidden_ssid(struct wmi_t *wmip, u8 hidden_ssid)
{
void *osbuf;
WMI_AP_HIDDEN_SSID_CMD *hs;
* in ioctl.c
*/
int
-wmi_ap_set_num_sta(struct wmi_t *wmip, A_UINT8 num_sta)
+wmi_ap_set_num_sta(struct wmi_t *wmip, u8 num_sta)
{
void *osbuf;
WMI_AP_SET_NUM_STA_CMD *ns;
* firware will allow all STAs till the count reaches AP_MAX_NUM_STA.
*/
int
-wmi_ap_set_mlme(struct wmi_t *wmip, A_UINT8 cmd, A_UINT8 *mac, A_UINT16 reason)
+wmi_ap_set_mlme(struct wmi_t *wmip, u8 cmd, u8 *mac, A_UINT16 reason)
{
void *osbuf;
WMI_AP_SET_MLME_CMD *mlme;
}
static int
-wmi_pspoll_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
+wmi_pspoll_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
WMI_PSPOLL_EVENT *ev;
}
static int
-wmi_dtimexpiry_event_rx(struct wmi_t *wmip, A_UINT8 *datap,int len)
+wmi_dtimexpiry_event_rx(struct wmi_t *wmip, u8 *datap,int len)
{
A_WMI_DTIMEXPIRY_EVENT(wmip->wmi_devt);
return A_OK;
#ifdef WAPI_ENABLE
static int
-wmi_wapi_rekey_event_rx(struct wmi_t *wmip, A_UINT8 *datap,int len)
+wmi_wapi_rekey_event_rx(struct wmi_t *wmip, u8 *datap,int len)
{
- A_UINT8 *ev;
+ u8 *ev;
if (len < 7) {
return A_EINVAL;
}
- ev = (A_UINT8 *)datap;
+ ev = (u8 *)datap;
A_WMI_WAPI_REKEY_EVENT(wmip->wmi_devt, *ev, &ev[1]);
return A_OK;
}
int
-wmi_ap_set_dtim(struct wmi_t *wmip, A_UINT8 dtim)
+wmi_ap_set_dtim(struct wmi_t *wmip, u8 dtim)
{
WMI_AP_SET_DTIM_CMD *cmd;
void *osbuf = NULL;
* If there is no chage in policy, the list will be intact.
*/
int
-wmi_ap_set_acl_policy(struct wmi_t *wmip, A_UINT8 policy)
+wmi_ap_set_acl_policy(struct wmi_t *wmip, u8 policy)
{
void *osbuf;
WMI_AP_ACL_POLICY_CMD *po;
}
int
-wmi_ap_set_rateset(struct wmi_t *wmip, A_UINT8 rateset)
+wmi_ap_set_rateset(struct wmi_t *wmip, u8 rateset)
{
void *osbuf;
WMI_AP_SET_11BG_RATESET_CMD *rs;
{
void *osbuf;
WMI_SET_HT_CAP_CMD *htCap;
- A_UINT8 band;
+ u8 band;
osbuf = A_NETBUF_ALLOC(sizeof(*htCap));
if (osbuf == NULL) {
}
int
-wmi_set_ht_op_cmd(struct wmi_t *wmip, A_UINT8 sta_chan_width)
+wmi_set_ht_op_cmd(struct wmi_t *wmip, u8 sta_chan_width)
{
void *osbuf;
WMI_SET_HT_OP_CMD *htInfo;
int
-wmi_send_hci_cmd(struct wmi_t *wmip, A_UINT8 *buf, A_UINT16 sz)
+wmi_send_hci_cmd(struct wmi_t *wmip, u8 *buf, A_UINT16 sz)
{
void *osbuf;
WMI_HCI_CMD *cmd;
}
int
-wmi_setup_aggr_cmd(struct wmi_t *wmip, A_UINT8 tid)
+wmi_setup_aggr_cmd(struct wmi_t *wmip, u8 tid)
{
void *osbuf;
WMI_ADDBA_REQ_CMD *cmd;
}
int
-wmi_delete_aggr_cmd(struct wmi_t *wmip, A_UINT8 tid, bool uplink)
+wmi_delete_aggr_cmd(struct wmi_t *wmip, u8 tid, bool uplink)
{
void *osbuf;
WMI_DELBA_REQ_CMD *cmd;
#endif
int
-wmi_set_rx_frame_format_cmd(struct wmi_t *wmip, A_UINT8 rxMetaVersion,
+wmi_set_rx_frame_format_cmd(struct wmi_t *wmip, u8 rxMetaVersion,
bool rxDot11Hdr, bool defragOnHost)
{
void *osbuf;
}
int
-wmi_set_pmk_cmd(struct wmi_t *wmip, A_UINT8 *pmk)
+wmi_set_pmk_cmd(struct wmi_t *wmip, u8 *pmk)
{
void *osbuf;
WMI_SET_PMK_CMD *p;
}
int
-wmi_SGI_cmd(struct wmi_t *wmip, A_UINT32 sgiMask, A_UINT8 sgiPERThreshold)
+wmi_SGI_cmd(struct wmi_t *wmip, A_UINT32 sgiMask, u8 sgiPERThreshold)
{
void *osbuf;
WMI_SET_TX_SGI_PARAM_CMD *cmd;
A_UINT32 upper_threshold_valid_count;
A_UINT32 lower_threshold_valid_count;
A_UINT32 polling_interval;
- A_UINT8 weight;
- A_UINT8 last_rssi; //normally you would expect this to be bss specific but we keep only one instance because its only valid when the device is in a connected state. Not sure if it belongs to host or target.
- A_UINT8 last_rssi_poll_event; //Not sure if it belongs to host or target
+ u8 weight;
+ u8 last_rssi; //normally you would expect this to be bss specific but we keep only one instance because its only valid when the device is in a connected state. Not sure if it belongs to host or target.
+ u8 last_rssi_poll_event; //Not sure if it belongs to host or target
} SQ_THRESHOLD_PARAMS;
/*
bool wmi_ready;
bool wmi_numQoSStream;
A_UINT16 wmi_streamExistsForAC[WMM_NUM_AC];
- A_UINT8 wmi_fatPipeExists;
+ u8 wmi_fatPipeExists;
void *wmi_devt;
struct wmi_stats wmi_stats;
struct ieee80211_node_table wmi_scan_table;
- A_UINT8 wmi_bssid[ATH_MAC_LEN];
- A_UINT8 wmi_powerMode;
- A_UINT8 wmi_phyMode;
- A_UINT8 wmi_keepaliveInterval;
+ u8 wmi_bssid[ATH_MAC_LEN];
+ u8 wmi_powerMode;
+ u8 wmi_phyMode;
+ u8 wmi_keepaliveInterval;
#ifdef THREAD_X
A_CSECT_T wmi_lock;
#else
CRYPTO_TYPE wmi_pair_crypto_type;
CRYPTO_TYPE wmi_grp_crypto_type;
bool wmi_is_wmm_enabled;
- A_UINT8 wmi_ht_allowed[A_NUM_BANDS];
- A_UINT8 wmi_traffic_class;
+ u8 wmi_ht_allowed[A_NUM_BANDS];
+ u8 wmi_traffic_class;
};
#ifdef THREAD_X
projects / GitHub / MotorolaMobilityLLC / kernel-slsi.git / commitdiff