int
bmiBufferSend(HIF_DEVICE *device,
A_UCHAR *buffer,
- A_UINT32 length);
+ u32 length);
int
bmiBufferReceive(HIF_DEVICE *device,
A_UCHAR *buffer,
- A_UINT32 length,
+ u32 length,
bool want_timeout);
#endif
*/
static bool pendingEventsFuncCheck = false;
-static A_UINT32 *pBMICmdCredits;
+static u32 *pBMICmdCredits;
static A_UCHAR *pBMICmdBuf;
#define MAX_BMI_CMDBUF_SZ (BMI_DATASZ_MAX + \
- sizeof(A_UINT32) /* cmd */ + \
- sizeof(A_UINT32) /* addr */ + \
- sizeof(A_UINT32))/* length */
+ sizeof(u32) /* cmd */ + \
+ sizeof(u32) /* addr */ + \
+ sizeof(u32))/* length */
#define BMI_COMMAND_FITS(sz) ((sz) <= MAX_BMI_CMDBUF_SZ)
/* APIs visible to the driver */
* bus stack.
*/
if (!pBMICmdCredits) {
- pBMICmdCredits = (A_UINT32 *)A_MALLOC_NOWAIT(4);
+ pBMICmdCredits = (u32 *)A_MALLOC_NOWAIT(4);
A_ASSERT(pBMICmdCredits);
}
BMIDone(HIF_DEVICE *device)
{
int status;
- A_UINT32 cid;
+ u32 cid;
if (bmiDone) {
AR_DEBUG_PRINTF (ATH_DEBUG_BMI, ("BMIDone skipped\n"));
BMIGetTargetInfo(HIF_DEVICE *device, struct bmi_target_info *targ_info)
{
int status;
- A_UINT32 cid;
+ u32 cid;
if (bmiDone) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Command disallowed\n"));
int
BMIReadMemory(HIF_DEVICE *device,
- A_UINT32 address,
+ u32 address,
A_UCHAR *buffer,
- A_UINT32 length)
+ u32 length)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
- A_UINT32 remaining, rxlen;
+ u32 offset;
+ u32 remaining, rxlen;
A_ASSERT(BMI_COMMAND_FITS(BMI_DATASZ_MAX + sizeof(cid) + sizeof(address) + sizeof(length)));
memset (pBMICmdBuf, 0, BMI_DATASZ_MAX + sizeof(cid) + sizeof(address) + sizeof(length));
int
BMIWriteMemory(HIF_DEVICE *device,
- A_UINT32 address,
+ u32 address,
A_UCHAR *buffer,
- A_UINT32 length)
+ u32 length)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
- A_UINT32 remaining, txlen;
- const A_UINT32 header = sizeof(cid) + sizeof(address) + sizeof(length);
+ u32 offset;
+ u32 remaining, txlen;
+ const u32 header = sizeof(cid) + sizeof(address) + sizeof(length);
A_UCHAR alignedBuffer[BMI_DATASZ_MAX];
A_UCHAR *src;
int
BMIExecute(HIF_DEVICE *device,
- A_UINT32 address,
- A_UINT32 *param)
+ u32 address,
+ u32 *param)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
+ u32 offset;
A_ASSERT(BMI_COMMAND_FITS(sizeof(cid) + sizeof(address) + sizeof(param)));
memset (pBMICmdBuf, 0, sizeof(cid) + sizeof(address) + sizeof(param));
int
BMISetAppStart(HIF_DEVICE *device,
- A_UINT32 address)
+ u32 address)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
+ u32 offset;
A_ASSERT(BMI_COMMAND_FITS(sizeof(cid) + sizeof(address)));
memset (pBMICmdBuf, 0, sizeof(cid) + sizeof(address));
int
BMIReadSOCRegister(HIF_DEVICE *device,
- A_UINT32 address,
- A_UINT32 *param)
+ u32 address,
+ u32 *param)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
+ u32 offset;
A_ASSERT(BMI_COMMAND_FITS(sizeof(cid) + sizeof(address)));
memset (pBMICmdBuf, 0, sizeof(cid) + sizeof(address));
int
BMIWriteSOCRegister(HIF_DEVICE *device,
- A_UINT32 address,
- A_UINT32 param)
+ u32 address,
+ u32 param)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
+ u32 offset;
A_ASSERT(BMI_COMMAND_FITS(sizeof(cid) + sizeof(address) + sizeof(param)));
memset (pBMICmdBuf, 0, sizeof(cid) + sizeof(address) + sizeof(param));
int
BMIrompatchInstall(HIF_DEVICE *device,
- A_UINT32 ROM_addr,
- A_UINT32 RAM_addr,
- A_UINT32 nbytes,
- A_UINT32 do_activate,
- A_UINT32 *rompatch_id)
+ u32 ROM_addr,
+ u32 RAM_addr,
+ u32 nbytes,
+ u32 do_activate,
+ u32 *rompatch_id)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
+ u32 offset;
A_ASSERT(BMI_COMMAND_FITS(sizeof(cid) + sizeof(ROM_addr) + sizeof(RAM_addr) +
sizeof(nbytes) + sizeof(do_activate)));
int
BMIrompatchUninstall(HIF_DEVICE *device,
- A_UINT32 rompatch_id)
+ u32 rompatch_id)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
+ u32 offset;
A_ASSERT(BMI_COMMAND_FITS(sizeof(cid) + sizeof(rompatch_id)));
memset (pBMICmdBuf, 0, sizeof(cid) + sizeof(rompatch_id));
static int
_BMIrompatchChangeActivation(HIF_DEVICE *device,
- A_UINT32 rompatch_count,
- A_UINT32 *rompatch_list,
- A_UINT32 do_activate)
+ u32 rompatch_count,
+ u32 *rompatch_list,
+ u32 do_activate)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
- A_UINT32 length;
+ u32 offset;
+ u32 length;
A_ASSERT(BMI_COMMAND_FITS(BMI_DATASZ_MAX + sizeof(cid) + sizeof(rompatch_count)));
memset(pBMICmdBuf, 0, BMI_DATASZ_MAX + sizeof(cid) + sizeof(rompatch_count));
int
BMIrompatchActivate(HIF_DEVICE *device,
- A_UINT32 rompatch_count,
- A_UINT32 *rompatch_list)
+ u32 rompatch_count,
+ u32 *rompatch_list)
{
return _BMIrompatchChangeActivation(device, rompatch_count, rompatch_list, 1);
}
int
BMIrompatchDeactivate(HIF_DEVICE *device,
- A_UINT32 rompatch_count,
- A_UINT32 *rompatch_list)
+ u32 rompatch_count,
+ u32 *rompatch_list)
{
return _BMIrompatchChangeActivation(device, rompatch_count, rompatch_list, 0);
}
int
BMILZData(HIF_DEVICE *device,
A_UCHAR *buffer,
- A_UINT32 length)
+ u32 length)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
- A_UINT32 remaining, txlen;
- const A_UINT32 header = sizeof(cid) + sizeof(length);
+ u32 offset;
+ u32 remaining, txlen;
+ const u32 header = sizeof(cid) + sizeof(length);
A_ASSERT(BMI_COMMAND_FITS(BMI_DATASZ_MAX+header));
memset (pBMICmdBuf, 0, BMI_DATASZ_MAX+header);
int
BMILZStreamStart(HIF_DEVICE *device,
- A_UINT32 address)
+ u32 address)
{
- A_UINT32 cid;
+ u32 cid;
int status;
- A_UINT32 offset;
+ u32 offset;
A_ASSERT(BMI_COMMAND_FITS(sizeof(cid) + sizeof(address)));
memset (pBMICmdBuf, 0, sizeof(cid) + sizeof(address));
int
bmiBufferSend(HIF_DEVICE *device,
A_UCHAR *buffer,
- A_UINT32 length)
+ u32 length)
{
int status;
- A_UINT32 timeout;
- A_UINT32 address;
- A_UINT32 mboxAddress[HTC_MAILBOX_NUM_MAX];
+ u32 timeout;
+ u32 address;
+ u32 mboxAddress[HTC_MAILBOX_NUM_MAX];
HIFConfigureDevice(device, HIF_DEVICE_GET_MBOX_ADDR,
&mboxAddress[0], sizeof(mboxAddress));
int
bmiBufferReceive(HIF_DEVICE *device,
A_UCHAR *buffer,
- A_UINT32 length,
+ u32 length,
bool want_timeout)
{
int status;
- A_UINT32 address;
- A_UINT32 mboxAddress[HTC_MAILBOX_NUM_MAX];
+ u32 address;
+ u32 mboxAddress[HTC_MAILBOX_NUM_MAX];
HIF_PENDING_EVENTS_INFO hifPendingEvents;
static HIF_PENDING_EVENTS_FUNC getPendingEventsFunc = NULL;
* NB: word_available is declared static for esoteric reasons
* having to do with protection on some OSes.
*/
- static A_UINT32 word_available;
- A_UINT32 timeout;
+ static u32 word_available;
+ u32 timeout;
word_available = 0;
timeout = BMI_COMMUNICATION_TIMEOUT;
break;
}
- if (hifPendingEvents.AvailableRecvBytes >= sizeof(A_UINT32)) {
+ if (hifPendingEvents.AvailableRecvBytes >= sizeof(u32)) {
word_available = 1;
}
continue;
* reduce BMI_DATASZ_MAX to 32 or 64
*/
if ((length > 4) && (length < 128)) { /* check against MBOX FIFO size */
- A_UINT32 timeout;
+ u32 timeout;
*pBMICmdCredits = 0;
timeout = BMI_COMMUNICATION_TIMEOUT;
}
int
-BMIFastDownload(HIF_DEVICE *device, A_UINT32 address, A_UCHAR *buffer, A_UINT32 length)
+BMIFastDownload(HIF_DEVICE *device, u32 address, A_UCHAR *buffer, u32 length)
{
int status = A_ERROR;
- A_UINT32 lastWord = 0;
- A_UINT32 lastWordOffset = length & ~0x3;
- A_UINT32 unalignedBytes = length & 0x3;
+ u32 lastWord = 0;
+ u32 lastWordOffset = length & ~0x3;
+ u32 unalignedBytes = length & 0x3;
status = BMILZStreamStart (device, address);
if (status) {
}
int
-BMIRawWrite(HIF_DEVICE *device, A_UCHAR *buffer, A_UINT32 length)
+BMIRawWrite(HIF_DEVICE *device, A_UCHAR *buffer, u32 length)
{
return bmiBufferSend(device, buffer, length);
}
int
-BMIRawRead(HIF_DEVICE *device, A_UCHAR *buffer, A_UINT32 length, bool want_timeout)
+BMIRawRead(HIF_DEVICE *device, A_UCHAR *buffer, u32 length, bool want_timeout)
{
return bmiBufferReceive(device, buffer, length, want_timeout);
}
struct bus_request *next; /* link list of available requests */
struct bus_request *inusenext; /* link list of in use requests */
struct semaphore sem_req;
- A_UINT32 address; /* request data */
+ u32 address; /* request data */
A_UCHAR *buffer;
- A_UINT32 length;
- A_UINT32 request;
+ u32 length;
+ u32 request;
void *context;
int status;
struct _HIF_SCATTER_REQ_PRIV *pScatterReq; /* this request is a scatter request */
int reset_sdio_on_unload = 0;
module_param(reset_sdio_on_unload, int, 0644);
-extern A_UINT32 nohifscattersupport;
+extern u32 nohifscattersupport;
/* ------ Static Variables ------ */
static int registered = 0;
OSDRV_CALLBACKS osdrvCallbacks;
-extern A_UINT32 onebitmode;
-extern A_UINT32 busspeedlow;
-extern A_UINT32 debughif;
+extern u32 onebitmode;
+extern u32 busspeedlow;
+extern u32 debughif;
static void ResetAllCards(void);
static int hifDisableFunc(HIF_DEVICE *device, struct sdio_func *func);
static int
__HIFReadWrite(HIF_DEVICE *device,
- A_UINT32 address,
+ u32 address,
A_UCHAR *buffer,
- A_UINT32 length,
- A_UINT32 request,
+ u32 length,
+ u32 request,
void *context)
{
u8 opcode;
/* queue a read/write request */
int
HIFReadWrite(HIF_DEVICE *device,
- A_UINT32 address,
+ u32 address,
A_UCHAR *buffer,
- A_UINT32 length,
- A_UINT32 request,
+ u32 length,
+ u32 request,
void *context)
{
int status = A_OK;
return 0;
}
-static A_INT32 IssueSDCommand(HIF_DEVICE *device, A_UINT32 opcode, A_UINT32 arg, A_UINT32 flags, A_UINT32 *resp)
+static A_INT32 IssueSDCommand(HIF_DEVICE *device, u32 opcode, u32 arg, u32 flags, u32 *resp)
{
struct mmc_command cmd;
A_INT32 err;
struct mmc_card *card;
struct sdio_func *func;
u8 cmd52_resp;
- A_UINT32 clock;
+ u32 clock;
func = device->func;
card = func->card;
do {
if (!device->is_suspend) {
- A_UINT32 resp;
+ u32 resp;
u16 rca;
- A_UINT32 i;
+ u32 i;
int bit = fls(host->ocr_avail) - 1;
/* emulate the mmc_power_up(...) */
host->ios.vdd = bit;
int
HIFConfigureDevice(HIF_DEVICE *device, HIF_DEVICE_CONFIG_OPCODE opcode,
- void *config, A_UINT32 configLen)
+ void *config, u32 configLen)
{
- A_UINT32 count;
+ u32 count;
int status = A_OK;
switch(opcode) {
case HIF_DEVICE_GET_MBOX_BLOCK_SIZE:
- ((A_UINT32 *)config)[0] = HIF_MBOX0_BLOCK_SIZE;
- ((A_UINT32 *)config)[1] = HIF_MBOX1_BLOCK_SIZE;
- ((A_UINT32 *)config)[2] = HIF_MBOX2_BLOCK_SIZE;
- ((A_UINT32 *)config)[3] = HIF_MBOX3_BLOCK_SIZE;
+ ((u32 *)config)[0] = HIF_MBOX0_BLOCK_SIZE;
+ ((u32 *)config)[1] = HIF_MBOX1_BLOCK_SIZE;
+ ((u32 *)config)[2] = HIF_MBOX2_BLOCK_SIZE;
+ ((u32 *)config)[3] = HIF_MBOX3_BLOCK_SIZE;
break;
case HIF_DEVICE_GET_MBOX_ADDR:
for (count = 0; count < 4; count ++) {
- ((A_UINT32 *)config)[count] = HIF_MBOX_START_ADDR(count);
+ ((u32 *)config)[count] = HIF_MBOX_START_ADDR(count);
}
if (configLen >= sizeof(HIF_DEVICE_MBOX_INFO)) {
static int HifReadWriteScatter(HIF_DEVICE *device, HIF_SCATTER_REQ *pReq)
{
int status = A_EINVAL;
- A_UINT32 request = pReq->Request;
+ u32 request = pReq->Request;
HIF_SCATTER_REQ_PRIV *pReqPriv = (HIF_SCATTER_REQ_PRIV *)pReq->HIFPrivate[0];
do {
int DevSetup(AR6K_DEVICE *pDev)
{
- A_UINT32 blocksizes[AR6K_MAILBOXES];
+ u32 blocksizes[AR6K_MAILBOXES];
int status = A_OK;
int i;
HTC_CALLBACKS htcCallbacks;
}
}
-int DevWaitForPendingRecv(AR6K_DEVICE *pDev,A_UINT32 TimeoutInMs,bool *pbIsRecvPending)
+int DevWaitForPendingRecv(AR6K_DEVICE *pDev,u32 TimeoutInMs,bool *pbIsRecvPending)
{
int status = A_OK;
A_UCHAR host_int_status = 0x0;
- A_UINT32 counter = 0x0;
+ u32 counter = 0x0;
if(TimeoutInMs < 100)
{
{
u8 *pDMABuffer = NULL;
int i, remaining;
- A_UINT32 length;
+ u32 length;
pDMABuffer = pReq->pScatterBounceBuffer;
AR6K_DEVICE *pDev = (AR6K_DEVICE *)Context;
int status = A_OK;
HTC_PACKET *pIOPacket = NULL;
- A_UINT32 request = pReq->Request;
+ u32 request = pReq->Request;
do {
/* read operation */
pScatterReq->Request = (Async) ? HIF_RD_ASYNC_BLOCK_FIX : HIF_RD_SYNC_BLOCK_FIX;
pScatterReq->Address = pDev->MailBoxInfo.MboxAddresses[HTC_MAILBOX];
- A_ASSERT(pScatterReq->TotalLength <= (A_UINT32)DEV_GET_MAX_BUNDLE_RECV_LENGTH(pDev));
+ A_ASSERT(pScatterReq->TotalLength <= (u32)DEV_GET_MAX_BUNDLE_RECV_LENGTH(pDev));
} else {
- A_UINT32 mailboxWidth;
+ u32 mailboxWidth;
/* write operation */
pScatterReq->Request = (Async) ? HIF_WR_ASYNC_BLOCK_INC : HIF_WR_SYNC_BLOCK_INC;
- A_ASSERT(pScatterReq->TotalLength <= (A_UINT32)DEV_GET_MAX_BUNDLE_SEND_LENGTH(pDev));
+ A_ASSERT(pScatterReq->TotalLength <= (u32)DEV_GET_MAX_BUNDLE_SEND_LENGTH(pDev));
if (pScatterReq->TotalLength > AR6K_LEGACY_MAX_WRITE_LENGTH) {
/* for large writes use the extended address */
pScatterReq->Address = pDev->MailBoxInfo.MboxProp[HTC_MAILBOX].ExtendedAddress;
#define TEST_CREDITS_RECV_TIMEOUT 100
static u8 g_Buffer[TOTAL_BYTES];
-static A_UINT32 g_MailboxAddrs[AR6K_MAILBOXES];
-static A_UINT32 g_BlockSizes[AR6K_MAILBOXES];
+static u32 g_MailboxAddrs[AR6K_MAILBOXES];
+static u32 g_BlockSizes[AR6K_MAILBOXES];
#define BUFFER_PROC_LIST_DEPTH 4
typedef struct _BUFFER_PROC_LIST{
u8 *pBuffer;
- A_UINT32 length;
+ u32 length;
}BUFFER_PROC_LIST;
success = CheckOneBuffer((u16 *)checkList[i].pBuffer, checkList[i].length);
if (!success) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Buffer : 0x%X, Length:%d failed verify \n",
- (A_UINT32)checkList[i].pBuffer, checkList[i].length));
+ (u32)checkList[i].pBuffer, checkList[i].length));
break;
}
}
static int SendBuffers(AR6K_DEVICE *pDev, int mbox)
{
int status = A_OK;
- A_UINT32 request = HIF_WR_SYNC_BLOCK_INC;
+ u32 request = HIF_WR_SYNC_BLOCK_INC;
BUFFER_PROC_LIST sendList[BUFFER_PROC_LIST_DEPTH];
int i;
int totalBytes = 0;
int status = A_OK;
int timeout = TEST_CREDITS_RECV_TIMEOUT;
u8 credits = 0;
- A_UINT32 address;
+ u32 address;
while (true) {
static int RecvBuffers(AR6K_DEVICE *pDev, int mbox)
{
int status = A_OK;
- A_UINT32 request = HIF_RD_SYNC_BLOCK_INC;
+ u32 request = HIF_RD_SYNC_BLOCK_INC;
BUFFER_PROC_LIST recvList[BUFFER_PROC_LIST_DEPTH];
int curBuffer;
int credits;
u8 rx_lookahead_valid;
u8 host_int_status2;
u8 gmbox_rx_avail;
- A_UINT32 rx_lookahead[2];
- A_UINT32 rx_gmbox_lookahead_alias[2];
+ u32 rx_lookahead[2];
+ u32 rx_gmbox_lookahead_alias[2];
} POSTPACK AR6K_IRQ_PROC_REGISTERS;
#define AR6K_IRQ_PROC_REGS_SIZE sizeof(AR6K_IRQ_PROC_REGISTERS)
AR6K_IRQ_ENABLE_REGISTERS IrqEnableRegisters; /* cache-line safe with pads around */
u8 _Pad3[A_CACHE_LINE_PAD];
void *HIFDevice;
- A_UINT32 BlockSize;
- A_UINT32 BlockMask;
+ u32 BlockSize;
+ u32 BlockMask;
HIF_DEVICE_MBOX_INFO MailBoxInfo;
HIF_PENDING_EVENTS_FUNC GetPendingEventsFunc;
void *HTCContext;
AR6K_ASYNC_REG_IO_BUFFER RegIOBuffers[AR6K_MAX_REG_IO_BUFFERS];
void (*TargetFailureCallback)(void *Context);
int (*MessagePendingCallback)(void *Context,
- A_UINT32 LookAheads[],
+ u32 LookAheads[],
int NumLookAheads,
bool *pAsyncProc,
int *pNumPktsFetched);
int DevUnmaskInterrupts(AR6K_DEVICE *pDev);
int DevMaskInterrupts(AR6K_DEVICE *pDev);
int DevPollMboxMsgRecv(AR6K_DEVICE *pDev,
- A_UINT32 *pLookAhead,
+ u32 *pLookAhead,
int TimeoutMS);
int DevRWCompletionHandler(void *context, int status);
int DevDsrHandler(void *context);
int DevEnableRecv(AR6K_DEVICE *pDev, bool ASyncMode);
int DevEnableInterrupts(AR6K_DEVICE *pDev);
int DevDisableInterrupts(AR6K_DEVICE *pDev);
-int DevWaitForPendingRecv(AR6K_DEVICE *pDev,A_UINT32 TimeoutInMs,bool *pbIsRecvPending);
+int DevWaitForPendingRecv(AR6K_DEVICE *pDev,u32 TimeoutInMs,bool *pbIsRecvPending);
#define DEV_CALC_RECV_PADDED_LEN(pDev, length) (((length) + (pDev)->BlockMask) & (~((pDev)->BlockMask)))
#define DEV_CALC_SEND_PADDED_LEN(pDev, length) DEV_CALC_RECV_PADDED_LEN(pDev,length)
#define DEV_IS_LEN_BLOCK_ALIGNED(pDev, length) (((length) % (pDev)->BlockSize) == 0)
-static INLINE int DevSendPacket(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, A_UINT32 SendLength) {
- A_UINT32 paddedLength;
+static INLINE int DevSendPacket(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, u32 SendLength) {
+ u32 paddedLength;
bool sync = (pPacket->Completion == NULL) ? true : false;
int status;
return status;
}
-static INLINE int DevRecvPacket(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, A_UINT32 RecvLength) {
- A_UINT32 paddedLength;
+static INLINE int DevRecvPacket(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, u32 RecvLength) {
+ u32 paddedLength;
int status;
bool sync = (pPacket->Completion == NULL) ? true : false;
#define DEV_GMBOX_GET_PROTOCOL(pDev) (pDev)->GMboxInfo.pProtocolContext
-int DevGMboxWrite(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, A_UINT32 WriteLength);
-int DevGMboxRead(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, A_UINT32 ReadLength);
+int DevGMboxWrite(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, u32 WriteLength);
+int DevGMboxRead(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, u32 ReadLength);
#define PROC_IO_ASYNC true
#define PROC_IO_SYNC false
/* mailbox recv message polling */
int DevPollMboxMsgRecv(AR6K_DEVICE *pDev,
- A_UINT32 *pLookAhead,
+ u32 *pLookAhead,
int TimeoutMS)
{
int status = A_OK;
static int DevServiceDebugInterrupt(AR6K_DEVICE *pDev)
{
- A_UINT32 dummy;
+ u32 dummy;
int status;
/* Send a target failure event to the application */
static void DevGetEventAsyncHandler(void *Context, HTC_PACKET *pPacket)
{
AR6K_DEVICE *pDev = (AR6K_DEVICE *)Context;
- A_UINT32 lookAhead = 0;
+ u32 lookAhead = 0;
bool otherInts = false;
AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("+DevGetEventAsyncHandler: (dev: 0x%lX)\n", (unsigned long)pDev));
{
int status = A_OK;
u8 host_int_status = 0;
- A_UINT32 lookAhead = 0;
+ u32 lookAhead = 0;
AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("+ProcessPendingIRQs: (dev: 0x%lX)\n", (unsigned long)pDev));
}
-int DevGMboxWrite(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, A_UINT32 WriteLength)
+int DevGMboxWrite(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, u32 WriteLength)
{
- A_UINT32 paddedLength;
+ u32 paddedLength;
bool sync = (pPacket->Completion == NULL) ? true : false;
int status;
- A_UINT32 address;
+ u32 address;
/* adjust the length to be a multiple of block size if appropriate */
paddedLength = DEV_CALC_SEND_PADDED_LEN(pDev, WriteLength);
return status;
}
-int DevGMboxRead(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, A_UINT32 ReadLength)
+int DevGMboxRead(AR6K_DEVICE *pDev, HTC_PACKET *pPacket, u32 ReadLength)
{
- A_UINT32 paddedLength;
+ u32 paddedLength;
int status;
bool sync = (pPacket->Completion == NULL) ? true : false;
HCI_TRANSPORT_CONFIG_INFO HCIConfig;
bool HCIAttached;
bool HCIStopped;
- A_UINT32 RecvStateFlags;
- A_UINT32 SendStateFlags;
+ u32 RecvStateFlags;
+ u32 SendStateFlags;
HCI_TRANSPORT_PACKET_TYPE WaitBufferType;
HTC_PACKET_QUEUE SendQueue; /* write queue holding HCI Command and ACL packets */
HTC_PACKET_QUEUE HCIACLRecvBuffers; /* recv queue holding buffers for incomming ACL packets */
#define LSB_SCRATCH_IDX 4
#define MSB_SCRATCH_IDX 5
-int HCI_TransportSetBaudRate(HCI_TRANSPORT_HANDLE HciTrans, A_UINT32 Baud)
+int HCI_TransportSetBaudRate(HCI_TRANSPORT_HANDLE HciTrans, u32 Baud)
{
GMBOX_PROTO_HCI_UART *pProt = (GMBOX_PROTO_HCI_UART *)HciTrans;
HIF_DEVICE *pHIFDevice = (HIF_DEVICE *)(pProt->pDev->HIFDevice);
- A_UINT32 scaledBaud, scratchAddr;
+ u32 scaledBaud, scratchAddr;
int status = A_OK;
/* Divide the desired baud rate by 100
HTC_TARGET *target = NULL;
int status = A_OK;
int i;
- A_UINT32 ctrl_bufsz;
- A_UINT32 blocksizes[HTC_MAILBOX_NUM_MAX];
+ u32 ctrl_bufsz;
+ u32 blocksizes[HTC_MAILBOX_NUM_MAX];
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("HTCCreate - Enter\n"));
int RxProcessCount; /* reference count to allow single processing context */
struct _HTC_TARGET *target; /* back pointer to target */
u8 SeqNo; /* TX seq no (helpful) for debugging */
- A_UINT32 LocalConnectionFlags; /* local connection flags */
+ u32 LocalConnectionFlags; /* local connection flags */
#ifdef HTC_EP_STAT_PROFILING
HTC_ENDPOINT_STATS EndPointStats; /* endpoint statistics */
#endif
A_MUTEX_T HTCRxLock;
A_MUTEX_T HTCTxLock;
AR6K_DEVICE Device; /* AR6K - specific state */
- A_UINT32 OpStateFlags;
- A_UINT32 RecvStateFlags;
+ u32 OpStateFlags;
+ u32 RecvStateFlags;
HTC_ENDPOINT_ID EpWaitingForBuffers;
bool TargetFailure;
#ifdef HTC_CAPTURE_LAST_FRAME
void HTCFreeControlBuffer(HTC_TARGET *target, HTC_PACKET *pPacket, HTC_PACKET_QUEUE *pList);
int HTCIssueSend(HTC_TARGET *target, HTC_PACKET *pPacket);
void HTCRecvCompleteHandler(void *Context, HTC_PACKET *pPacket);
-int HTCRecvMessagePendingHandler(void *Context, A_UINT32 MsgLookAheads[], int NumLookAheads, bool *pAsyncProc, int *pNumPktsFetched);
+int HTCRecvMessagePendingHandler(void *Context, u32 MsgLookAheads[], int NumLookAheads, bool *pAsyncProc, int *pNumPktsFetched);
void HTCProcessCreditRpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, int NumEntries, HTC_ENDPOINT_ID FromEndpoint);
int HTCSendSetupComplete(HTC_TARGET *target);
void HTCFlushRecvBuffers(HTC_TARGET *target);
static INLINE int HTCProcessTrailer(HTC_TARGET *target,
u8 *pBuffer,
int Length,
- A_UINT32 *pNextLookAheads,
+ u32 *pNextLookAheads,
int *pNumLookAheads,
HTC_ENDPOINT_ID FromEndpoint)
{
* note : locks must be released when this function is called */
static int HTCProcessRecvHeader(HTC_TARGET *target,
HTC_PACKET *pPacket,
- A_UINT32 *pNextLookAheads,
+ u32 *pNextLookAheads,
int *pNumLookAheads)
{
u8 temp;
u8 *pBuf;
int status = A_OK;
u16 payloadLen;
- A_UINT32 lookAhead;
+ u32 lookAhead;
pBuf = pPacket->pBuffer;
}
static INLINE void HTCAsyncRecvCheckMorePackets(HTC_TARGET *target,
- A_UINT32 NextLookAheads[],
+ u32 NextLookAheads[],
int NumLookAheads,
bool CheckMoreMsgs)
{
("Next look ahead from recv header was INVALID\n"));
#ifdef ATH_DEBUG_MODULE
DebugDumpBytes((u8 *)NextLookAheads,
- NumLookAheads * (sizeof(A_UINT32)),
+ NumLookAheads * (sizeof(u32)),
"BAD lookaheads from lookahead report");
#endif
}
(P)->PktInfo.AsRx.IndicationFlags |= HTC_RX_FLAGS_INDICATE_MORE_PKTS;
/* note: this function can be called with the RX lock held */
-static INLINE void SetRxPacketIndicationFlags(A_UINT32 LookAhead,
+static INLINE void SetRxPacketIndicationFlags(u32 LookAhead,
HTC_ENDPOINT *pEndpoint,
HTC_PACKET *pPacket)
{
{
HTC_TARGET *target = (HTC_TARGET *)Context;
HTC_ENDPOINT *pEndpoint;
- A_UINT32 nextLookAheads[HTC_HOST_MAX_MSG_PER_BUNDLE];
+ u32 nextLookAheads[HTC_HOST_MAX_MSG_PER_BUNDLE];
int numLookAheads = 0;
int status;
bool checkMorePkts = true;
int HTCWaitforControlMessage(HTC_TARGET *target, HTC_PACKET **ppControlPacket)
{
int status;
- A_UINT32 lookAhead;
+ u32 lookAhead;
HTC_PACKET *pPacket = NULL;
HTC_FRAME_HDR *pHdr;
}
static int AllocAndPrepareRxPackets(HTC_TARGET *target,
- A_UINT32 LookAheads[],
+ u32 LookAheads[],
int Messages,
HTC_ENDPOINT *pEndpoint,
HTC_PACKET_QUEUE *pQueue)
if (pHdr->PayloadLen > HTC_MAX_PAYLOAD_LENGTH) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Payload length %d exceeds max HTC : %d !\n",
- pHdr->PayloadLen, (A_UINT32)HTC_MAX_PAYLOAD_LENGTH));
+ pHdr->PayloadLen, (u32)HTC_MAX_PAYLOAD_LENGTH));
status = A_EPROTO;
break;
}
}
/* make sure this message can fit in the endpoint buffer */
- if ((A_UINT32)fullLength > pPacket->BufferLength) {
+ if ((u32)fullLength > pPacket->BufferLength) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("Payload Length Error : header reports payload of: %d (%d) endpoint buffer size: %d \n",
pHdr->PayloadLen, fullLength, pPacket->BufferLength));
int i;
HTC_PACKET *pPacket;
HTC_ENDPOINT *pEndpoint;
- A_UINT32 lookAheads[HTC_HOST_MAX_MSG_PER_BUNDLE];
+ u32 lookAheads[HTC_HOST_MAX_MSG_PER_BUNDLE];
int numLookAheads = 0;
HTC_TARGET *target = (HTC_TARGET *)pScatterReq->Context;
int status;
}
/* callback when device layer or lookahead report parsing detects a pending message */
-int HTCRecvMessagePendingHandler(void *Context, A_UINT32 MsgLookAheads[], int NumLookAheads, bool *pAsyncProc, int *pNumPktsFetched)
+int HTCRecvMessagePendingHandler(void *Context, u32 MsgLookAheads[], int NumLookAheads, bool *pAsyncProc, int *pNumPktsFetched)
{
HTC_TARGET *target = (HTC_TARGET *)Context;
int status = A_OK;
HTC_PACKET *pPacket;
HTC_ENDPOINT *pEndpoint;
bool asyncProc = false;
- A_UINT32 lookAheads[HTC_HOST_MAX_MSG_PER_BUNDLE];
+ u32 lookAheads[HTC_HOST_MAX_MSG_PER_BUNDLE];
int pktsFetched;
HTC_PACKET_QUEUE recvPktQueue, syncCompletedPktsQueue;
bool partialBundle;
}
/* on first entry copy the lookaheads into our temp array for processing */
- A_MEMCPY(lookAheads, MsgLookAheads, (sizeof(A_UINT32)) * NumLookAheads);
+ A_MEMCPY(lookAheads, MsgLookAheads, (sizeof(u32)) * NumLookAheads);
while (true) {
}
int HTCWaitForPendingRecv(HTC_HANDLE HTCHandle,
- A_UINT32 TimeoutInMs,
+ u32 TimeoutInMs,
bool *pbIsRecvPending)
{
int status = A_OK;
AR_DEBUG_PRINTF(ATH_DEBUG_SEND,
("+-HTCIssueSend: transmit length : %d (%s) \n",
- pPacket->ActualLength + (A_UINT32)HTC_HDR_LENGTH,
+ pPacket->ActualLength + (u32)HTC_HDR_LENGTH,
sync ? "SYNC" : "ASYNC" ));
/* send message to device */
if (pPacket->ActualLength > 0) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("HTCControlRecv, got message with length:%d \n",
- pPacket->ActualLength + (A_UINT32)HTC_HDR_LENGTH));
+ pPacket->ActualLength + (u32)HTC_HDR_LENGTH));
#ifdef ATH_DEBUG_MODULE
/* dump header and message */
if (target->HTCTargetVersion >= HTC_VERSION_2P1) {
HTC_SETUP_COMPLETE_EX_MSG *pSetupCompleteEx;
- A_UINT32 setupFlags = 0;
+ u32 setupFlags = 0;
pSetupCompleteEx = (HTC_SETUP_COMPLETE_EX_MSG *)pSendPacket->pBuffer;
A_MEMZERO(pSetupCompleteEx, sizeof(HTC_SETUP_COMPLETE_EX_MSG));
#define ATH_DEBUG_MAX_MOD_DESC_LENGTH 64
typedef struct {
- A_UINT32 Mask;
+ u32 Mask;
char Description[ATH_DEBUG_MAX_MASK_DESC_LENGTH];
} ATH_DEBUG_MASK_DESCRIPTION;
struct _ATH_DEBUG_MODULE_DBG_INFO *pNext;
char ModuleName[16];
char ModuleDescription[ATH_DEBUG_MAX_MOD_DESC_LENGTH];
- A_UINT32 Flags;
- A_UINT32 CurrentMask;
+ u32 Flags;
+ u32 CurrentMask;
int MaxDescriptions;
ATH_DEBUG_MASK_DESCRIPTION *pMaskDescriptions; /* pointer to array of descriptions */
} ATH_DEBUG_MODULE_DBG_INFO;
#endif
-int a_get_module_mask(char *module_name, A_UINT32 *pMask);
-int a_set_module_mask(char *module_name, A_UINT32 Mask);
+int a_get_module_mask(char *module_name, u32 *pMask);
+int a_set_module_mask(char *module_name, u32 Mask);
void a_dump_module_debug_info_by_name(char *module_name);
void a_module_debug_support_init(void);
void a_module_debug_support_cleanup(void);
typedef struct {
- A_UINT32 Flags; /* config flags */
+ u32 Flags; /* config flags */
void *pHCIDev; /* HCI bridge device */
HCI_TRANSPORT_PROPERTIES *pHCIProps; /* HCI bridge props */
HIF_DEVICE *pHIFDevice; /* HIF layer device */
- A_UINT32 AR3KBaudRate; /* AR3K operational baud rate */
+ u32 AR3KBaudRate; /* AR3K operational baud rate */
u16 AR6KScale; /* AR6K UART scale value */
u16 AR6KStep; /* AR6K UART step value */
struct hci_dev *pBtStackHCIDev; /* BT Stack HCI dev */
- A_UINT32 PwrMgmtEnabled; /* TLPM enabled? */
+ u32 PwrMgmtEnabled; /* TLPM enabled? */
u16 IdleTimeout; /* TLPM idle timeout */
u16 WakeupTimeout; /* TLPM wakeup timeout */
u8 bdaddr[6]; /* Bluetooth device address */
int
-ar6000_ReadRegDiag(HIF_DEVICE *hifDevice, A_UINT32 *address, A_UINT32 *data);
+ar6000_ReadRegDiag(HIF_DEVICE *hifDevice, u32 *address, u32 *data);
int
-ar6000_WriteRegDiag(HIF_DEVICE *hifDevice, A_UINT32 *address, A_UINT32 *data);
+ar6000_WriteRegDiag(HIF_DEVICE *hifDevice, u32 *address, u32 *data);
int
-ar6000_ReadDataDiag(HIF_DEVICE *hifDevice, A_UINT32 address,
- A_UCHAR *data, A_UINT32 length);
+ar6000_ReadDataDiag(HIF_DEVICE *hifDevice, u32 address,
+ A_UCHAR *data, u32 length);
int
-ar6000_WriteDataDiag(HIF_DEVICE *hifDevice, A_UINT32 address,
- A_UCHAR *data, A_UINT32 length);
+ar6000_WriteDataDiag(HIF_DEVICE *hifDevice, u32 address,
+ A_UCHAR *data, u32 length);
int
-ar6k_ReadTargetRegister(HIF_DEVICE *hifDevice, int regsel, A_UINT32 *regval);
+ar6k_ReadTargetRegister(HIF_DEVICE *hifDevice, int regsel, u32 *regval);
void
-ar6k_FetchTargetRegs(HIF_DEVICE *hifDevice, A_UINT32 *targregs);
+ar6k_FetchTargetRegs(HIF_DEVICE *hifDevice, u32 *targregs);
#endif /*AR6000_DIAG_H_*/
int
BMIReadMemory(HIF_DEVICE *device,
- A_UINT32 address,
+ u32 address,
A_UCHAR *buffer,
- A_UINT32 length);
+ u32 length);
int
BMIWriteMemory(HIF_DEVICE *device,
- A_UINT32 address,
+ u32 address,
A_UCHAR *buffer,
- A_UINT32 length);
+ u32 length);
int
BMIExecute(HIF_DEVICE *device,
- A_UINT32 address,
- A_UINT32 *param);
+ u32 address,
+ u32 *param);
int
BMISetAppStart(HIF_DEVICE *device,
- A_UINT32 address);
+ u32 address);
int
BMIReadSOCRegister(HIF_DEVICE *device,
- A_UINT32 address,
- A_UINT32 *param);
+ u32 address,
+ u32 *param);
int
BMIWriteSOCRegister(HIF_DEVICE *device,
- A_UINT32 address,
- A_UINT32 param);
+ u32 address,
+ u32 param);
int
BMIrompatchInstall(HIF_DEVICE *device,
- A_UINT32 ROM_addr,
- A_UINT32 RAM_addr,
- A_UINT32 nbytes,
- A_UINT32 do_activate,
- A_UINT32 *patch_id);
+ u32 ROM_addr,
+ u32 RAM_addr,
+ u32 nbytes,
+ u32 do_activate,
+ u32 *patch_id);
int
BMIrompatchUninstall(HIF_DEVICE *device,
- A_UINT32 rompatch_id);
+ u32 rompatch_id);
int
BMIrompatchActivate(HIF_DEVICE *device,
- A_UINT32 rompatch_count,
- A_UINT32 *rompatch_list);
+ u32 rompatch_count,
+ u32 *rompatch_list);
int
BMIrompatchDeactivate(HIF_DEVICE *device,
- A_UINT32 rompatch_count,
- A_UINT32 *rompatch_list);
+ u32 rompatch_count,
+ u32 *rompatch_list);
int
BMILZStreamStart(HIF_DEVICE *device,
- A_UINT32 address);
+ u32 address);
int
BMILZData(HIF_DEVICE *device,
A_UCHAR *buffer,
- A_UINT32 length);
+ u32 length);
int
BMIFastDownload(HIF_DEVICE *device,
- A_UINT32 address,
+ u32 address,
A_UCHAR *buffer,
- A_UINT32 length);
+ u32 length);
int
BMIRawWrite(HIF_DEVICE *device,
A_UCHAR *buffer,
- A_UINT32 length);
+ u32 length);
int
BMIRawRead(HIF_DEVICE *device,
A_UCHAR *buffer,
- A_UINT32 length,
+ u32 length,
bool want_timeout);
#ifdef __cplusplus
* This must match the state saved by the target exception handler.
*/
struct XTensa_exception_frame_s {
- A_UINT32 xt_pc;
- A_UINT32 xt_ps;
- A_UINT32 xt_sar;
- A_UINT32 xt_vpri;
- A_UINT32 xt_a2;
- A_UINT32 xt_a3;
- A_UINT32 xt_a4;
- A_UINT32 xt_a5;
- A_UINT32 xt_exccause;
- A_UINT32 xt_lcount;
- A_UINT32 xt_lbeg;
- A_UINT32 xt_lend;
+ u32 xt_pc;
+ u32 xt_ps;
+ u32 xt_sar;
+ u32 xt_vpri;
+ u32 xt_a2;
+ u32 xt_a3;
+ u32 xt_a4;
+ u32 xt_a5;
+ u32 xt_exccause;
+ u32 xt_lcount;
+ u32 xt_lbeg;
+ u32 xt_lend;
- A_UINT32 epc1, epc2, epc3, epc4;
+ u32 epc1, epc2, epc3, epc4;
/* Extra info to simplify post-mortem stack walkback */
#define AR6002_REGDUMP_FRAMES 10
struct {
- A_UINT32 a0; /* pc */
- A_UINT32 a1; /* sp */
- A_UINT32 a2;
- A_UINT32 a3;
+ u32 a0; /* pc */
+ u32 a1; /* sp */
+ u32 a2;
+ u32 a3;
} wb[AR6002_REGDUMP_FRAMES];
};
typedef struct XTensa_exception_frame_s CPU_exception_frame_t;
#if defined(AR6002_REV2)
#define AR6K_RAM_START 0x00500000
-#define TARG_RAM_OFFSET(vaddr) ((A_UINT32)(vaddr) & 0xfffff)
+#define TARG_RAM_OFFSET(vaddr) ((u32)(vaddr) & 0xfffff)
#define TARG_RAM_SZ (184*1024)
#define TARG_ROM_SZ (80*1024)
#endif
#if defined(AR6002_REV4) || defined(AR6003)
#define AR6K_RAM_START 0x00540000
-#define TARG_RAM_OFFSET(vaddr) (((A_UINT32)(vaddr) & 0xfffff) - 0x40000)
+#define TARG_RAM_OFFSET(vaddr) (((u32)(vaddr) & 0xfffff) - 0x40000)
#define TARG_RAM_SZ (256*1024)
#define TARG_ROM_SZ (256*1024)
#endif
#define TARG_RAM_ADDRS(byte_offset) AR6K_RAM_ADDR(byte_offset)
#define AR6K_ROM_START 0x004e0000
-#define TARG_ROM_OFFSET(vaddr) (((A_UINT32)(vaddr) & 0x1fffff) - 0xe0000)
+#define TARG_ROM_OFFSET(vaddr) (((u32)(vaddr) & 0x1fffff) - 0xe0000)
#define AR6K_ROM_ADDR(byte_offset) (AR6K_ROM_START+(byte_offset))
#define TARG_ROM_ADDRS(byte_offset) AR6K_ROM_ADDR(byte_offset)
u8 id;
u8 service_type;
u16 max_sdu;
- A_UINT32 sdu_inter_arrival_time;
- A_UINT32 access_latency;
- A_UINT32 flush_timeout;
+ u32 sdu_inter_arrival_time;
+ u32 access_latency;
+ u32 flush_timeout;
} POSTPACK FLOW_SPEC;
typedef struct local_amp_info_resp_t {
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;
+ u32 total_bw; /* kbps */
+ u32 max_guranteed_bw; /* kbps */
+ u32 min_latency;
+ u32 max_pdu_size;
u8 amp_type;
u16 pal_capabilities;
u16 amp_assoc_len;
- A_UINT32 max_flush_timeout; /* in ms */
- A_UINT32 be_flush_timeout; /* in ms */
+ u32 max_flush_timeout; /* in ms */
+ u32 be_flush_timeout; /* in ms */
} POSTPACK LOCAL_AMP_INFO;
typedef struct amp_assoc_cmd_resp_t{
/*
* Semantics: Host is done using BMI
* Request format:
- * A_UINT32 command (BMI_DONE)
+ * u32 command (BMI_DONE)
* Response format: none
*/
/*
* Semantics: Host reads AR6K memory
* Request format:
- * A_UINT32 command (BMI_READ_MEMORY)
- * A_UINT32 address
- * A_UINT32 length, at most BMI_DATASZ_MAX
+ * u32 command (BMI_READ_MEMORY)
+ * u32 address
+ * u32 length, at most BMI_DATASZ_MAX
* Response format:
* u8 data[length]
*/
/*
* Semantics: Host writes AR6K memory
* Request format:
- * A_UINT32 command (BMI_WRITE_MEMORY)
- * A_UINT32 address
- * A_UINT32 length, at most BMI_DATASZ_MAX
+ * u32 command (BMI_WRITE_MEMORY)
+ * u32 address
+ * u32 length, at most BMI_DATASZ_MAX
* u8 data[length]
* Response format: none
*/
/*
* Semantics: Causes AR6K to execute code
* Request format:
- * A_UINT32 command (BMI_EXECUTE)
- * A_UINT32 address
- * A_UINT32 parameter
+ * u32 command (BMI_EXECUTE)
+ * u32 address
+ * u32 parameter
* Response format:
- * A_UINT32 return value
+ * u32 return value
*/
#define BMI_SET_APP_START 5
/*
* Semantics: Set Target application starting address
* Request format:
- * A_UINT32 command (BMI_SET_APP_START)
- * A_UINT32 address
+ * u32 command (BMI_SET_APP_START)
+ * u32 address
* Response format: none
*/
/*
* Semantics: Read a 32-bit Target SOC register.
* Request format:
- * A_UINT32 command (BMI_READ_REGISTER)
- * A_UINT32 address
+ * u32 command (BMI_READ_REGISTER)
+ * u32 address
* Response format:
- * A_UINT32 value
+ * u32 value
*/
#define BMI_WRITE_SOC_REGISTER 7
/*
* Semantics: Write a 32-bit Target SOC register.
* Request format:
- * A_UINT32 command (BMI_WRITE_REGISTER)
- * A_UINT32 address
- * A_UINT32 value
+ * u32 command (BMI_WRITE_REGISTER)
+ * u32 address
+ * u32 value
*
* Response format: none
*/
/*
* Semantics: Fetch the 4-byte Target information
* Request format:
- * A_UINT32 command (BMI_GET_TARGET_ID/INFO)
+ * u32 command (BMI_GET_TARGET_ID/INFO)
* Response format1 (old firmware):
- * A_UINT32 TargetVersionID
+ * u32 TargetVersionID
* Response format2 (newer firmware):
- * A_UINT32 TARGET_VERSION_SENTINAL
+ * u32 TARGET_VERSION_SENTINAL
* struct bmi_target_info;
*/
PREPACK struct bmi_target_info {
- A_UINT32 target_info_byte_count; /* size of this structure */
- A_UINT32 target_ver; /* Target Version ID */
- A_UINT32 target_type; /* Target type */
+ u32 target_info_byte_count; /* size of this structure */
+ u32 target_ver; /* Target Version ID */
+ u32 target_type; /* Target type */
} POSTPACK;
#define TARGET_VERSION_SENTINAL 0xffffffff
#define TARGET_TYPE_AR6001 1
/*
* Semantics: Install a ROM Patch.
* Request format:
- * A_UINT32 command (BMI_ROMPATCH_INSTALL)
- * A_UINT32 Target ROM Address
- * A_UINT32 Target RAM Address or Value (depending on Target Type)
- * A_UINT32 Size, in bytes
- * A_UINT32 Activate? 1-->activate;
+ * u32 command (BMI_ROMPATCH_INSTALL)
+ * u32 Target ROM Address
+ * u32 Target RAM Address or Value (depending on Target Type)
+ * u32 Size, in bytes
+ * u32 Activate? 1-->activate;
* 0-->install but do not activate
* Response format:
- * A_UINT32 PatchID
+ * u32 PatchID
*/
#define BMI_ROMPATCH_UNINSTALL 10
* Semantics: Uninstall a previously-installed ROM Patch,
* automatically deactivating, if necessary.
* Request format:
- * A_UINT32 command (BMI_ROMPATCH_UNINSTALL)
- * A_UINT32 PatchID
+ * u32 command (BMI_ROMPATCH_UNINSTALL)
+ * u32 PatchID
*
* Response format: none
*/
/*
* Semantics: Activate a list of previously-installed ROM Patches.
* Request format:
- * A_UINT32 command (BMI_ROMPATCH_ACTIVATE)
- * A_UINT32 rompatch_count
- * A_UINT32 PatchID[rompatch_count]
+ * u32 command (BMI_ROMPATCH_ACTIVATE)
+ * u32 rompatch_count
+ * u32 PatchID[rompatch_count]
*
* Response format: none
*/
/*
* Semantics: Deactivate a list of active ROM Patches.
* Request format:
- * A_UINT32 command (BMI_ROMPATCH_DEACTIVATE)
- * A_UINT32 rompatch_count
- * A_UINT32 PatchID[rompatch_count]
+ * u32 command (BMI_ROMPATCH_DEACTIVATE)
+ * u32 rompatch_count
+ * u32 PatchID[rompatch_count]
*
* Response format: none
*/
* output from the compressed input stream. This BMI
* command should be followed by a series of 1 or more
* BMI_LZ_DATA commands.
- * A_UINT32 command (BMI_LZ_STREAM_START)
- * A_UINT32 address
+ * u32 command (BMI_LZ_STREAM_START)
+ * u32 address
* Note: Not supported on all versions of ROM firmware.
*/
* of BMI_LZ_DATA commands are considered part of a single
* input stream until another BMI_LZ_STREAM_START is issued.
* Request format:
- * A_UINT32 command (BMI_LZ_DATA)
- * A_UINT32 length (of compressed data),
+ * u32 command (BMI_LZ_DATA)
+ * u32 length (of compressed data),
* at most BMI_DATASZ_MAX
* u8 CompressedData[length]
* Response format: none
-extern void btcoexDbgPulseWord(A_UINT32 gpioPinMask);
-extern void btcoexDbgPulse(A_UINT32 pin);
+extern void btcoexDbgPulseWord(u32 gpioPinMask);
+extern void btcoexDbgPulse(u32 pin);
#ifdef CONFIG_BTCOEX_ENABLE_GPIO_DEBUG
#define BTCOEX_DBG_PULSE_WORD(gpioPinMask) (btcoexDbgPulseWord(gpioPinMask))
PREPACK struct dbglog_buf_s {
struct dbglog_buf_s *next;
u8 *buffer;
- A_UINT32 bufsize;
- A_UINT32 length;
- A_UINT32 count;
- A_UINT32 free;
+ u32 bufsize;
+ u32 length;
+ u32 count;
+ u32 free;
} POSTPACK;
PREPACK struct dbglog_hdr_s {
struct dbglog_buf_s *dbuf;
- A_UINT32 dropped;
+ u32 dropped;
} POSTPACK;
PREPACK struct dbglog_config_s {
- A_UINT32 cfgvalid; /* Mask with valid config bits */
+ u32 cfgvalid; /* Mask with valid config bits */
union {
/* TODO: Take care of endianness */
struct {
- A_UINT32 mmask:16; /* Mask of modules with logging on */
- A_UINT32 rep:1; /* Reporting enabled or not */
- A_UINT32 tsr:3; /* Time stamp resolution. Def: 1 ms */
- A_UINT32 size:10; /* Report size in number of messages */
- A_UINT32 reserved:2;
+ u32 mmask:16; /* Mask of modules with logging on */
+ u32 rep:1; /* Reporting enabled or not */
+ u32 tsr:3; /* Time stamp resolution. Def: 1 ms */
+ u32 size:10; /* Report size in number of messages */
+ u32 reserved:2;
} dbglog_config;
- A_UINT32 value;
+ u32 value;
} u;
} POSTPACK;
DataSet or pointer to original
dset_descriptor for patched
DataSet */
- A_UINT32 data_type; /* DSET_TYPE_*, above */
+ u32 data_type; /* DSET_TYPE_*, above */
void *AuxPtr; /* Additional data that might
needed for data_type. For
* This allows for patches to be stored in flash.
*/
PREPACK struct patch_s {
- A_UINT32 *address;
- A_UINT32 data;
+ u32 *address;
+ u32 data;
} POSTPACK ;
/*
* patch code. The "data" in a PATCH_SKIP tells how many
* bytes of length "patch_s" to skip.
*/
-#define PATCH_SKIP ((A_UINT32 *)0x00000000)
+#define PATCH_SKIP ((u32 *)0x00000000)
/*
* Execute code at the address specified by "data".
* The address of the patch structure is passed as
* the one parameter.
*/
-#define PATCH_CODE_ABS ((A_UINT32 *)0x00000001)
+#define PATCH_CODE_ABS ((u32 *)0x00000001)
/*
* Same as PATCH_CODE_ABS, but treat "data" as an
* offset from the start of the patch word.
*/
-#define PATCH_CODE_REL ((A_UINT32 *)0x00000002)
+#define PATCH_CODE_REL ((u32 *)0x00000002)
/* Mark the end of this patch DataSet. */
-#define PATCH_END ((A_UINT32 *)0xffffffff)
+#define PATCH_END ((u32 *)0xffffffff)
/*
* A DataSet which contains a Binary Patch to some other DataSet
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) */
+ u32 HostContext_h; /* 4 byte host context, target echos this back */
+ u32 SeqNo; /* sequence number (set by host or target) */
u16 Cmd_h; /* ping command (filled by host) */
u16 CmdFlags_h; /* optional flags */
u8 CmdBuffer_h[8]; /* buffer for command (host -> target) */
/* extended setup completion message */
typedef PREPACK struct {
u16 MessageID;
- A_UINT32 SetupFlags;
+ u32 SetupFlags;
u8 MaxMsgsPerBundledRecv;
u8 Rsvd[3];
} POSTPACK HTC_SETUP_COMPLETE_EX_MSG;
typedef PREPACK struct {
u16 freqIndex; // 1 - A mode 2 - B or G mode 0 - common
u16 offset;
- A_UINT32 newValue;
+ u32 newValue;
} POSTPACK INI_DSET_REG_OVERRIDE;
#endif
* the diagnostic window.
*/
PREPACK struct register_dump_s {
- A_UINT32 target_id; /* Target ID */
- A_UINT32 assline; /* Line number (if assertion failure) */
- A_UINT32 pc; /* Program Counter at time of exception */
- A_UINT32 badvaddr; /* Virtual address causing exception */
+ u32 target_id; /* Target ID */
+ u32 assline; /* Line number (if assertion failure) */
+ u32 pc; /* Program Counter at time of exception */
+ u32 badvaddr; /* Virtual address causing exception */
CPU_exception_frame_t exc_frame; /* CPU-specific exception info */
/* Could copy top of stack here, too.... */
#define BMZERO {0,0} /* BMLEN zeros */
#define BM(_fa, _fb, _fc, _fd, _fe, _ff, _fg, _fh) \
- {((((_fa >= 0) && (_fa < 32)) ? (((A_UINT32) 1) << _fa) : 0) | \
- (((_fb >= 0) && (_fb < 32)) ? (((A_UINT32) 1) << _fb) : 0) | \
- (((_fc >= 0) && (_fc < 32)) ? (((A_UINT32) 1) << _fc) : 0) | \
- (((_fd >= 0) && (_fd < 32)) ? (((A_UINT32) 1) << _fd) : 0) | \
- (((_fe >= 0) && (_fe < 32)) ? (((A_UINT32) 1) << _fe) : 0) | \
- (((_ff >= 0) && (_ff < 32)) ? (((A_UINT32) 1) << _ff) : 0) | \
- (((_fg >= 0) && (_fg < 32)) ? (((A_UINT32) 1) << _fg) : 0) | \
- (((_fh >= 0) && (_fh < 32)) ? (((A_UINT32) 1) << _fh) : 0)), \
- ((((_fa > 31) && (_fa < 64)) ? (((A_UINT32) 1) << (_fa - 32)) : 0) | \
- (((_fb > 31) && (_fb < 64)) ? (((A_UINT32) 1) << (_fb - 32)) : 0) | \
- (((_fc > 31) && (_fc < 64)) ? (((A_UINT32) 1) << (_fc - 32)) : 0) | \
- (((_fd > 31) && (_fd < 64)) ? (((A_UINT32) 1) << (_fd - 32)) : 0) | \
- (((_fe > 31) && (_fe < 64)) ? (((A_UINT32) 1) << (_fe - 32)) : 0) | \
- (((_ff > 31) && (_ff < 64)) ? (((A_UINT32) 1) << (_ff - 32)) : 0) | \
- (((_fg > 31) && (_fg < 64)) ? (((A_UINT32) 1) << (_fg - 32)) : 0) | \
- (((_fh > 31) && (_fh < 64)) ? (((A_UINT32) 1) << (_fh - 32)) : 0))}
+ {((((_fa >= 0) && (_fa < 32)) ? (((u32) 1) << _fa) : 0) | \
+ (((_fb >= 0) && (_fb < 32)) ? (((u32) 1) << _fb) : 0) | \
+ (((_fc >= 0) && (_fc < 32)) ? (((u32) 1) << _fc) : 0) | \
+ (((_fd >= 0) && (_fd < 32)) ? (((u32) 1) << _fd) : 0) | \
+ (((_fe >= 0) && (_fe < 32)) ? (((u32) 1) << _fe) : 0) | \
+ (((_ff >= 0) && (_ff < 32)) ? (((u32) 1) << _ff) : 0) | \
+ (((_fg >= 0) && (_fg < 32)) ? (((u32) 1) << _fg) : 0) | \
+ (((_fh >= 0) && (_fh < 32)) ? (((u32) 1) << _fh) : 0)), \
+ ((((_fa > 31) && (_fa < 64)) ? (((u32) 1) << (_fa - 32)) : 0) | \
+ (((_fb > 31) && (_fb < 64)) ? (((u32) 1) << (_fb - 32)) : 0) | \
+ (((_fc > 31) && (_fc < 64)) ? (((u32) 1) << (_fc - 32)) : 0) | \
+ (((_fd > 31) && (_fd < 64)) ? (((u32) 1) << (_fd - 32)) : 0) | \
+ (((_fe > 31) && (_fe < 64)) ? (((u32) 1) << (_fe - 32)) : 0) | \
+ (((_ff > 31) && (_ff < 64)) ? (((u32) 1) << (_ff - 32)) : 0) | \
+ (((_fg > 31) && (_fg < 64)) ? (((u32) 1) << (_fg - 32)) : 0) | \
+ (((_fh > 31) && (_fh < 64)) ? (((u32) 1) << (_fh - 32)) : 0))}
/*
u16 regDmn2GHz; /* 2GHz reg domain */
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
+ u32 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;
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
+ u32 usePassScan; /* Use Passive Scan in the RegDomain if corresponding bit is set */
+ u32 ht40ChanMask; /* lower 16 bits: indicate which frequencies in the block is HT40 capable
upper 16 bits: what rate (half/quarter) the channel is */
} POSTPACK REG_DMN_FREQ_BAND;
u8 dfsMask; /* DFS bitmask for 5Ghz tables */
u8 flags; /* Requirement flags (AdHoc disallow etc) */
u16 reserved; /* for alignment */
- A_UINT32 pscan; /* Bitmask for passive scan */
- A_UINT32 chan11a[BMLEN]; /* 64 bit bitmask for channel/band selection */
- A_UINT32 chan11bg[BMLEN];/* 64 bit bitmask for channel/band selection */
+ u32 pscan; /* Bitmask for passive scan */
+ u32 chan11a[BMLEN]; /* 64 bit bitmask for channel/band selection */
+ u32 chan11bg[BMLEN];/* 64 bit bitmask for channel/band selection */
} POSTPACK REG_DOMAIN;
#endif /* __REG_DBSCHEMA_H__ */
* Pointer to application-defined area, if any.
* Set by Target application during startup.
*/
- A_UINT32 hi_app_host_interest; /* 0x00 */
+ u32 hi_app_host_interest; /* 0x00 */
/* Pointer to register dump area, valid after Target crash. */
- A_UINT32 hi_failure_state; /* 0x04 */
+ u32 hi_failure_state; /* 0x04 */
/* Pointer to debug logging header */
- A_UINT32 hi_dbglog_hdr; /* 0x08 */
+ u32 hi_dbglog_hdr; /* 0x08 */
/* Indicates whether or not flash is present on Target.
* NB: flash_is_present indicator is here not just
* so that it doesn't get reinitialized with the rest
* of data.
*/
- A_UINT32 hi_flash_is_present; /* 0x0c */
+ u32 hi_flash_is_present; /* 0x0c */
/*
* General-purpose flag bits, similar to AR6000_OPTION_* flags.
* Can be used by application rather than by OS.
*/
- A_UINT32 hi_option_flag; /* 0x10 */
+ u32 hi_option_flag; /* 0x10 */
/*
* Boolean that determines whether or not to
* display messages on the serial port.
*/
- A_UINT32 hi_serial_enable; /* 0x14 */
+ u32 hi_serial_enable; /* 0x14 */
/* Start address of Flash DataSet index, if any */
- A_UINT32 hi_dset_list_head; /* 0x18 */
+ u32 hi_dset_list_head; /* 0x18 */
/* Override Target application start address */
- A_UINT32 hi_app_start; /* 0x1c */
+ u32 hi_app_start; /* 0x1c */
/* Clock and voltage tuning */
- A_UINT32 hi_skip_clock_init; /* 0x20 */
- A_UINT32 hi_core_clock_setting; /* 0x24 */
- A_UINT32 hi_cpu_clock_setting; /* 0x28 */
- A_UINT32 hi_system_sleep_setting; /* 0x2c */
- A_UINT32 hi_xtal_control_setting; /* 0x30 */
- A_UINT32 hi_pll_ctrl_setting_24ghz; /* 0x34 */
- A_UINT32 hi_pll_ctrl_setting_5ghz; /* 0x38 */
- A_UINT32 hi_ref_voltage_trim_setting; /* 0x3c */
- A_UINT32 hi_clock_info; /* 0x40 */
+ u32 hi_skip_clock_init; /* 0x20 */
+ u32 hi_core_clock_setting; /* 0x24 */
+ u32 hi_cpu_clock_setting; /* 0x28 */
+ u32 hi_system_sleep_setting; /* 0x2c */
+ u32 hi_xtal_control_setting; /* 0x30 */
+ u32 hi_pll_ctrl_setting_24ghz; /* 0x34 */
+ u32 hi_pll_ctrl_setting_5ghz; /* 0x38 */
+ u32 hi_ref_voltage_trim_setting; /* 0x3c */
+ u32 hi_clock_info; /* 0x40 */
/*
* Flash configuration overrides, used only
* (When using flash, modify the global variables
* with equivalent names.)
*/
- A_UINT32 hi_bank0_addr_value; /* 0x44 */
- A_UINT32 hi_bank0_read_value; /* 0x48 */
- A_UINT32 hi_bank0_write_value; /* 0x4c */
- A_UINT32 hi_bank0_config_value; /* 0x50 */
+ u32 hi_bank0_addr_value; /* 0x44 */
+ u32 hi_bank0_read_value; /* 0x48 */
+ u32 hi_bank0_write_value; /* 0x4c */
+ u32 hi_bank0_config_value; /* 0x50 */
/* Pointer to Board Data */
- A_UINT32 hi_board_data; /* 0x54 */
- A_UINT32 hi_board_data_initialized; /* 0x58 */
+ u32 hi_board_data; /* 0x54 */
+ u32 hi_board_data_initialized; /* 0x58 */
- A_UINT32 hi_dset_RAM_index_table; /* 0x5c */
+ u32 hi_dset_RAM_index_table; /* 0x5c */
- A_UINT32 hi_desired_baud_rate; /* 0x60 */
- A_UINT32 hi_dbglog_config; /* 0x64 */
- A_UINT32 hi_end_RAM_reserve_sz; /* 0x68 */
- A_UINT32 hi_mbox_io_block_sz; /* 0x6c */
+ u32 hi_desired_baud_rate; /* 0x60 */
+ u32 hi_dbglog_config; /* 0x64 */
+ u32 hi_end_RAM_reserve_sz; /* 0x68 */
+ u32 hi_mbox_io_block_sz; /* 0x6c */
- A_UINT32 hi_num_bpatch_streams; /* 0x70 -- unused */
- A_UINT32 hi_mbox_isr_yield_limit; /* 0x74 */
+ u32 hi_num_bpatch_streams; /* 0x70 -- unused */
+ u32 hi_mbox_isr_yield_limit; /* 0x74 */
- A_UINT32 hi_refclk_hz; /* 0x78 */
- A_UINT32 hi_ext_clk_detected; /* 0x7c */
- A_UINT32 hi_dbg_uart_txpin; /* 0x80 */
- A_UINT32 hi_dbg_uart_rxpin; /* 0x84 */
- A_UINT32 hi_hci_uart_baud; /* 0x88 */
- A_UINT32 hi_hci_uart_pin_assignments; /* 0x8C */
+ u32 hi_refclk_hz; /* 0x78 */
+ u32 hi_ext_clk_detected; /* 0x7c */
+ u32 hi_dbg_uart_txpin; /* 0x80 */
+ u32 hi_dbg_uart_rxpin; /* 0x84 */
+ u32 hi_hci_uart_baud; /* 0x88 */
+ u32 hi_hci_uart_pin_assignments; /* 0x8C */
/* NOTE: byte [0] = tx pin, [1] = rx pin, [2] = rts pin, [3] = cts pin */
- A_UINT32 hi_hci_uart_baud_scale_val; /* 0x90 */
- A_UINT32 hi_hci_uart_baud_step_val; /* 0x94 */
+ u32 hi_hci_uart_baud_scale_val; /* 0x90 */
+ u32 hi_hci_uart_baud_step_val; /* 0x94 */
- A_UINT32 hi_allocram_start; /* 0x98 */
- A_UINT32 hi_allocram_sz; /* 0x9c */
- A_UINT32 hi_hci_bridge_flags; /* 0xa0 */
- A_UINT32 hi_hci_uart_support_pins; /* 0xa4 */
+ u32 hi_allocram_start; /* 0x98 */
+ u32 hi_allocram_sz; /* 0x9c */
+ u32 hi_hci_bridge_flags; /* 0xa0 */
+ u32 hi_hci_uart_support_pins; /* 0xa4 */
/* NOTE: byte [0] = RESET pin (bit 7 is polarity), bytes[1]..bytes[3] are for future use */
- A_UINT32 hi_hci_uart_pwr_mgmt_params; /* 0xa8 */
+ u32 hi_hci_uart_pwr_mgmt_params; /* 0xa8 */
/* 0xa8 - [0]: 1 = enable, 0 = disable
* [1]: 0 = UART FC active low, 1 = UART FC active high
* 0xa9 - [7:0]: wakeup timeout in ms
* 0xaa, 0xab - [15:0]: idle timeout in ms
*/
/* Pointer to extended board Data */
- A_UINT32 hi_board_ext_data; /* 0xac */
- A_UINT32 hi_board_ext_data_initialized; /* 0xb0 */
+ u32 hi_board_ext_data; /* 0xac */
+ u32 hi_board_ext_data_initialized; /* 0xb0 */
} POSTPACK;
/* Bits defined in hi_option_flag */
* Example: target_addr = AR6002_HOST_INTEREST_ITEM_ADDRESS(hi_board_data);
*/
#define AR6002_HOST_INTEREST_ITEM_ADDRESS(item) \
- (A_UINT32)((unsigned long)&((((struct host_interest_s *)(AR6002_HOST_INTEREST_ADDRESS))->item)))
+ (u32)((unsigned long)&((((struct host_interest_s *)(AR6002_HOST_INTEREST_ADDRESS))->item)))
#define AR6003_HOST_INTEREST_ITEM_ADDRESS(item) \
- (A_UINT32)((unsigned long)&((((struct host_interest_s *)(AR6003_HOST_INTEREST_ADDRESS))->item)))
+ (u32)((unsigned long)&((((struct host_interest_s *)(AR6003_HOST_INTEREST_ADDRESS))->item)))
#define HOST_INTEREST_DBGLOG_IS_ENABLED() \
(!(HOST_INTEREST->hi_option_flag & HI_OPTION_DISABLE_DBGLOG))
#define AR6003_BOARD_EXT_DATA_ADDRESS 0x57E600
-/* # of A_UINT32 entries in targregs, used by DIAG_FETCH_TARG_REGS */
+/* # of u32 entries in targregs, used by DIAG_FETCH_TARG_REGS */
#define AR6003_FETCH_TARG_REGS_COUNT 64
#endif /* !__ASSEMBLER__ */
} TCMD_WLAN_MODE;
typedef PREPACK struct {
- A_UINT32 testCmdId;
- A_UINT32 mode;
- A_UINT32 freq;
- A_UINT32 dataRate;
+ u32 testCmdId;
+ u32 mode;
+ u32 freq;
+ u32 dataRate;
A_INT32 txPwr;
- A_UINT32 antenna;
- A_UINT32 enANI;
- A_UINT32 scramblerOff;
- A_UINT32 aifsn;
+ u32 antenna;
+ u32 enANI;
+ u32 scramblerOff;
+ u32 aifsn;
u16 pktSz;
u16 txPattern;
- A_UINT32 shortGuard;
- A_UINT32 numPackets;
- A_UINT32 wlanMode;
+ u32 shortGuard;
+ u32 numPackets;
+ u32 wlanMode;
} POSTPACK TCMD_CONT_TX;
#define TCMD_TXPATTERN_ZERONE 0x1
} TCMD_CONT_RX_ACT;
typedef PREPACK struct {
- A_UINT32 testCmdId;
- A_UINT32 act;
- A_UINT32 enANI;
+ u32 testCmdId;
+ u32 act;
+ u32 enANI;
PREPACK union {
struct PREPACK TCMD_CONT_RX_PARA {
- A_UINT32 freq;
- A_UINT32 antenna;
- A_UINT32 wlanMode;
+ u32 freq;
+ u32 antenna;
+ u32 wlanMode;
} POSTPACK para;
struct PREPACK TCMD_CONT_RX_REPORT {
- A_UINT32 totalPkt;
+ u32 totalPkt;
A_INT32 rssiInDBm;
- A_UINT32 crcErrPkt;
- A_UINT32 secErrPkt;
+ u32 crcErrPkt;
+ u32 secErrPkt;
u16 rateCnt[TCMD_MAX_RATES];
u16 rateCntShortGuard[TCMD_MAX_RATES];
} POSTPACK report;
A_UCHAR addr[ATH_MAC_LEN];
} POSTPACK mac;
struct PREPACK TCMD_CONT_RX_ANT_SWITCH_TABLE {
- A_UINT32 antswitch1;
- A_UINT32 antswitch2;
+ u32 antswitch1;
+ u32 antswitch2;
}POSTPACK antswitchtable;
} POSTPACK u;
} POSTPACK TCMD_CONT_RX;
} TCMD_PM_MODE;
typedef PREPACK struct {
- A_UINT32 testCmdId;
- A_UINT32 mode;
+ u32 testCmdId;
+ u32 mode;
} POSTPACK TCMD_PM;
typedef enum {
#endif
PREPACK struct host_app_area_s {
- A_UINT32 wmi_protocol_ver;
+ u32 wmi_protocol_ver;
} POSTPACK;
/*
A_UCHAR ssid[WMI_MAX_SSID_LEN];
u16 channel;
u8 bssid[ATH_MAC_LEN];
- A_UINT32 ctrl_flags;
+ u32 ctrl_flags;
} POSTPACK WMI_CONNECT_CMD;
/*
typedef PREPACK struct {
u32 forceFgScan;
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)*/
+ u32 homeDwellTime; /* Maximum duration in the home channel(milliseconds) */
+ u32 forceScanInterval; /* Time interval between scans (milliseconds)*/
u8 scanType; /* WMI_SCAN_TYPE */
u8 numChannels; /* how many channels follow */
u16 channelList[1]; /* channels in Mhz */
u8 scanCtrlFlags;
u16 minact_chdwell_time; /* msec */
u16 maxact_scan_per_ssid; /* max active scans per ssid */
- A_UINT32 max_dfsch_act_time; /* msecs */
+ u32 max_dfsch_act_time; /* msecs */
} POSTPACK WMI_SCAN_PARAMS_CMD;
/*
u8 bssFilter; /* see WMI_BSS_FILTER */
u8 reserved1; /* For alignment */
u16 reserved2; /* For alignment */
- A_UINT32 ieMask;
+ u32 ieMask;
} POSTPACK WMI_BSS_FILTER_CMD;
/*
} POSTPACK WMI_SET_PARAMS_REPLY;
typedef PREPACK struct {
- A_UINT32 opcode;
- A_UINT32 length;
+ u32 opcode;
+ u32 length;
char buffer[1]; /* WMI_SET_PARAMS */
} POSTPACK WMI_SET_PARAMS_CMD;
} WMI_AP_PS_TYPE;
typedef PREPACK struct {
- A_UINT32 idle_time; /* in msec */
- A_UINT32 ps_period; /* in usec */
+ u32 idle_time; /* in msec */
+ u32 ps_period; /* in usec */
u8 sleep_period; /* in ps periods */
u8 psType;
} POSTPACK WMI_AP_PS_CMD;
typedef PREPACK struct {
u16 psPollTimeout; /* msec */
u16 triggerTimeout; /* msec */
- A_UINT32 apsdTimPolicy; /* TIM behavior with ques APSD enabled. Default is IGNORE_TIM_ALL_QUEUES_APSD */
- A_UINT32 simulatedAPSDTimPolicy; /* TIM behavior with simulated APSD enabled. Default is PROCESS_TIM_SIMULATED_APSD */
+ u32 apsdTimPolicy; /* TIM behavior with ques APSD enabled. Default is IGNORE_TIM_ALL_QUEUES_APSD */
+ u32 simulatedAPSDTimPolicy; /* TIM behavior with simulated APSD enabled. Default is PROCESS_TIM_SIMULATED_APSD */
} POSTPACK WMI_POWERSAVE_TIMERS_POLICY_CMD;
/*
* WMI_CREATE_PSTREAM_CMDID
*/
typedef PREPACK struct {
- A_UINT32 minServiceInt; /* in milli-sec */
- A_UINT32 maxServiceInt; /* in milli-sec */
- A_UINT32 inactivityInt; /* in milli-sec */
- A_UINT32 suspensionInt; /* in milli-sec */
- A_UINT32 serviceStartTime;
- A_UINT32 minDataRate; /* in bps */
- A_UINT32 meanDataRate; /* in bps */
- A_UINT32 peakDataRate; /* in bps */
- A_UINT32 maxBurstSize;
- A_UINT32 delayBound;
- A_UINT32 minPhyRate; /* in bps */
- A_UINT32 sba;
- A_UINT32 mediumTime;
+ u32 minServiceInt; /* in milli-sec */
+ u32 maxServiceInt; /* in milli-sec */
+ u32 inactivityInt; /* in milli-sec */
+ u32 suspensionInt; /* in milli-sec */
+ u32 serviceStartTime;
+ u32 minDataRate; /* in bps */
+ u32 meanDataRate; /* in bps */
+ u32 peakDataRate; /* in bps */
+ u32 maxBurstSize;
+ u32 delayBound;
+ u32 minPhyRate; /* in bps */
+ u32 sba;
+ u32 mediumTime;
u16 nominalMSDU; /* in octects */
u16 maxMSDU; /* in octects */
u8 trafficClass;
*/
typedef PREPACK struct WMI_RSSI_THRESHOLD_PARAMS{
- A_UINT32 pollTime; /* Polling time as a factor of LI */
+ u32 pollTime; /* Polling time as a factor of LI */
A_INT16 thresholdAbove1_Val; /* lowest of upper */
A_INT16 thresholdAbove2_Val;
A_INT16 thresholdAbove3_Val;
*/
typedef PREPACK struct WMI_SNR_THRESHOLD_PARAMS{
- A_UINT32 pollTime; /* Polling time as a factor of LI */
+ u32 pollTime; /* Polling time as a factor of LI */
u8 weight; /* "alpha" */
u8 thresholdAbove1_Val; /* lowest of uppper*/
u8 thresholdAbove2_Val;
* via event, unless the bitmask is set again.
*/
typedef PREPACK struct {
- A_UINT32 bitmask;
+ u32 bitmask;
} POSTPACK WMI_TARGET_ERROR_REPORT_BITMASK;
/*
} POSTPACK WMI_SET_MAX_OFFHOME_DURATION_CMD;
typedef PREPACK struct {
- A_UINT32 frequency;
+ u32 frequency;
u8 threshold;
} POSTPACK WMI_SET_HB_CHALLENGE_RESP_PARAMS_CMD;
/*---------------------- BTCOEX RELATED -------------------------------------*/
#define BT_SCO_SET_MAX_LOW_RATE_CNT(flags,val) (flags) |= (((val) & 0xFF) << 16)
typedef PREPACK struct {
- A_UINT32 numScoCyclesForceTrigger; /* Number SCO cycles after which
+ u32 numScoCyclesForceTrigger; /* Number SCO cycles after which
force a pspoll. default = 10 */
- A_UINT32 dataResponseTimeout; /* Timeout Waiting for Downlink pkt
+ u32 dataResponseTimeout; /* Timeout Waiting for Downlink pkt
in response for ps-poll,
default = 10 msecs */
- A_UINT32 stompScoRules;
- A_UINT32 scoOptFlags; /* SCO Options Flags :
+ u32 stompScoRules;
+ u32 scoOptFlags; /* SCO Options Flags :
bits: meaning:
0 Allow Close Range Optimization
1 Force awake during close range
#define BT_A2DP_SET_MAX_LOW_RATE_CNT(flags,val) (flags) |= (((val) & 0xFF) << 16)
typedef PREPACK struct {
- A_UINT32 a2dpWlanUsageLimit; /* MAX time firmware uses the medium for
+ u32 a2dpWlanUsageLimit; /* MAX time firmware uses the medium for
wlan, after it identifies the idle time
default (30 msecs) */
- A_UINT32 a2dpBurstCntMin; /* Minimum number of bluetooth data frames
+ u32 a2dpBurstCntMin; /* Minimum number of bluetooth data frames
to replenish Wlan Usage limit (default 3) */
- A_UINT32 a2dpDataRespTimeout;
- A_UINT32 a2dpOptFlags; /* A2DP Option flags:
+ u32 a2dpDataRespTimeout;
+ u32 a2dpOptFlags; /* A2DP Option flags:
bits: meaning:
0 Allow Close Range Optimization
1 Force awake during close range
/* During BT ftp/ BT OPP or any another data based acl profile on bluetooth
(non a2dp).*/
typedef PREPACK struct {
- A_UINT32 aclWlanMediumUsageTime; /* Wlan usage time during Acl (non-a2dp)
+ u32 aclWlanMediumUsageTime; /* Wlan usage time during Acl (non-a2dp)
coexistence (default 30 msecs) */
- A_UINT32 aclBtMediumUsageTime; /* Bt usage time during acl coexistence
+ u32 aclBtMediumUsageTime; /* Bt usage time during acl coexistence
(default 30 msecs)*/
- A_UINT32 aclDataRespTimeout;
- A_UINT32 aclDetectTimeout; /* ACL coexistence enabled if we get
+ u32 aclDataRespTimeout;
+ u32 aclDetectTimeout; /* ACL coexistence enabled if we get
10 Pkts in X msec(default 100 msecs) */
- A_UINT32 aclmaxPktCnt; /* No of ACL pkts to receive before
+ u32 aclmaxPktCnt; /* No of ACL pkts to receive before
enabling ACL coex */
}POSTPACK BT_PARAMS_ACLCOEX;
* During this the station will be power-save mode.
*/
typedef PREPACK struct {
- A_UINT32 btInquiryDataFetchFrequency;/* The frequency of querying the AP for data
+ u32 btInquiryDataFetchFrequency;/* The frequency of querying the AP for data
(via pspoll) is configured by this parameter.
"default = 10 ms" */
- A_UINT32 protectBmissDurPostBtInquiry;/* The firmware will continue to be in inquiry state
+ u32 protectBmissDurPostBtInquiry;/* The firmware will continue to be in inquiry state
for configured duration, after inquiry completion
. This is to ensure other bluetooth transactions
(RDP, SDP profiles, link key exchange ...etc)
goes through smoothly without wifi stomping.
default = 10 secs*/
- A_UINT32 maxpageStomp; /*Applicable only for STE-BT interface. Currently not
+ u32 maxpageStomp; /*Applicable only for STE-BT interface. Currently not
used */
- A_UINT32 btInquiryPageFlag; /* Not used */
+ u32 btInquiryPageFlag; /* Not used */
}POSTPACK WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD;
/*---------------------WMI_SET_BTCOEX_SCO_CONFIG_CMDID ---------------*/
#define WMI_SCO_CONFIG_FLAG_IS_BT_MASTER (1 << 2)
#define WMI_SCO_CONFIG_FLAG_FW_DETECT_OF_PER (1 << 3)
typedef PREPACK struct {
- A_UINT32 scoSlots; /* Number of SCO Tx/Rx slots.
+ u32 scoSlots; /* Number of SCO Tx/Rx slots.
HVx, EV3, 2EV3 = 2 */
- A_UINT32 scoIdleSlots; /* Number of Bluetooth idle slots between
+ u32 scoIdleSlots; /* Number of Bluetooth idle slots between
consecutive SCO Tx/Rx slots
HVx, EV3 = 4
2EV3 = 10
*/
- A_UINT32 scoFlags; /* SCO Options Flags :
+ u32 scoFlags; /* SCO Options Flags :
bits: meaning:
0 Allow Close Range Optimization
1 Is EDR capable or Not
3 Firmware determines the periodicity of SCO.
*/
- A_UINT32 linkId; /* applicable to STE-BT - not used */
+ u32 linkId; /* applicable to STE-BT - not used */
}POSTPACK BTCOEX_SCO_CONFIG;
typedef PREPACK struct {
- A_UINT32 scoCyclesForceTrigger; /* Number SCO cycles after which
+ u32 scoCyclesForceTrigger; /* Number SCO cycles after which
force a pspoll. default = 10 */
- A_UINT32 scoDataResponseTimeout; /* Timeout Waiting for Downlink pkt
+ u32 scoDataResponseTimeout; /* Timeout Waiting for Downlink pkt
in response for ps-poll,
default = 20 msecs */
- A_UINT32 scoStompDutyCyleVal; /* not implemented */
+ u32 scoStompDutyCyleVal; /* not implemented */
- A_UINT32 scoStompDutyCyleMaxVal; /*Not implemented */
+ u32 scoStompDutyCyleMaxVal; /*Not implemented */
- A_UINT32 scoPsPollLatencyFraction; /* Fraction of idle
+ u32 scoPsPollLatencyFraction; /* Fraction of idle
period, within which
additional ps-polls can be queued
1 - 1/4 of idle duration
}POSTPACK BTCOEX_PSPOLLMODE_SCO_CONFIG;
typedef PREPACK struct {
- A_UINT32 scoStompCntIn100ms;/*max number of SCO stomp in 100ms allowed in
+ u32 scoStompCntIn100ms;/*max number of SCO stomp in 100ms allowed in
opt mode. If exceeds the configured value,
switch to ps-poll mode
default = 3 */
- A_UINT32 scoContStompMax; /* max number of continous stomp allowed in opt mode.
+ u32 scoContStompMax; /* max number of continous stomp allowed in opt mode.
if excedded switch to pspoll mode
default = 3 */
- A_UINT32 scoMinlowRateMbps; /* Low rate threshold */
+ u32 scoMinlowRateMbps; /* Low rate threshold */
- A_UINT32 scoLowRateCnt; /* number of low rate pkts (< scoMinlowRateMbps) allowed in 100 ms.
+ u32 scoLowRateCnt; /* number of low rate pkts (< scoMinlowRateMbps) allowed in 100 ms.
If exceeded switch/stay to ps-poll mode, lower stay in opt mode.
default = 36
*/
- A_UINT32 scoHighPktRatio; /*(Total Rx pkts in 100 ms + 1)/
+ u32 scoHighPktRatio; /*(Total Rx pkts in 100 ms + 1)/
((Total tx pkts in 100 ms - No of high rate pkts in 100 ms) + 1) in 100 ms,
if exceeded switch/stay in opt mode and if lower switch/stay in pspoll mode.
default = 5 (80% of high rates)
*/
- A_UINT32 scoMaxAggrSize; /* Max number of Rx subframes allowed in this mode. (Firmware re-negogiates
+ u32 scoMaxAggrSize; /* Max number of Rx subframes allowed in this mode. (Firmware re-negogiates
max number of aggregates if it was negogiated to higher value
default = 1
Recommended value Basic rate headsets = 1, EDR (2-EV3) =4.
}POSTPACK BTCOEX_OPTMODE_SCO_CONFIG;
typedef PREPACK struct {
- A_UINT32 scanInterval;
- A_UINT32 maxScanStompCnt;
+ u32 scanInterval;
+ u32 maxScanStompCnt;
}POSTPACK BTCOEX_WLANSCAN_SCO_CONFIG;
typedef PREPACK struct {
#define WMI_A2DP_CONFIG_FLAG_FIND_BT_ROLE (1 << 4)
typedef PREPACK struct {
- A_UINT32 a2dpFlags; /* A2DP Option flags:
+ u32 a2dpFlags; /* A2DP Option flags:
bits: meaning:
0 Allow Close Range Optimization
1 IS EDR capable
3 a2dp traffic is high priority
4 Fw detect the role of bluetooth.
*/
- A_UINT32 linkId; /* Applicable only to STE-BT - not used */
+ u32 linkId; /* Applicable only to STE-BT - not used */
}POSTPACK BTCOEX_A2DP_CONFIG;
typedef PREPACK struct {
- A_UINT32 a2dpWlanMaxDur; /* MAX time firmware uses the medium for
+ u32 a2dpWlanMaxDur; /* MAX time firmware uses the medium for
wlan, after it identifies the idle time
default (30 msecs) */
- A_UINT32 a2dpMinBurstCnt; /* Minimum number of bluetooth data frames
+ u32 a2dpMinBurstCnt; /* Minimum number of bluetooth data frames
to replenish Wlan Usage limit (default 3) */
- A_UINT32 a2dpDataRespTimeout; /* Max duration firmware waits for downlink
+ u32 a2dpDataRespTimeout; /* Max duration firmware waits for downlink
by stomping on bluetooth
after ps-poll is acknowledged.
default = 20 ms
}POSTPACK BTCOEX_PSPOLLMODE_A2DP_CONFIG;
typedef PREPACK struct {
- A_UINT32 a2dpMinlowRateMbps; /* Low rate threshold */
+ u32 a2dpMinlowRateMbps; /* Low rate threshold */
- A_UINT32 a2dpLowRateCnt; /* number of low rate pkts (< a2dpMinlowRateMbps) allowed in 100 ms.
+ u32 a2dpLowRateCnt; /* number of low rate pkts (< a2dpMinlowRateMbps) allowed in 100 ms.
If exceeded switch/stay to ps-poll mode, lower stay in opt mode.
default = 36
*/
- A_UINT32 a2dpHighPktRatio; /*(Total Rx pkts in 100 ms + 1)/
+ u32 a2dpHighPktRatio; /*(Total Rx pkts in 100 ms + 1)/
((Total tx pkts in 100 ms - No of high rate pkts in 100 ms) + 1) in 100 ms,
if exceeded switch/stay in opt mode and if lower switch/stay in pspoll mode.
default = 5 (80% of high rates)
*/
- A_UINT32 a2dpMaxAggrSize; /* Max number of Rx subframes allowed in this mode. (Firmware re-negogiates
+ u32 a2dpMaxAggrSize; /* Max number of Rx subframes allowed in this mode. (Firmware re-negogiates
max number of aggregates if it was negogiated to higher value
default = 1
Recommended value Basic rate headsets = 1, EDR (2-EV3) =8.
*/
- A_UINT32 a2dpPktStompCnt; /*number of a2dp pkts that can be stomped per burst.
+ u32 a2dpPktStompCnt; /*number of a2dp pkts that can be stomped per burst.
default = 6*/
}POSTPACK BTCOEX_OPTMODE_A2DP_CONFIG;
#define WMI_ACLCOEX_FLAGS_DISABLE_FW_DETECTION (1 << 1)
typedef PREPACK struct {
- A_UINT32 aclWlanMediumDur; /* Wlan usage time during Acl (non-a2dp)
+ u32 aclWlanMediumDur; /* Wlan usage time during Acl (non-a2dp)
coexistence (default 30 msecs)
*/
- A_UINT32 aclBtMediumDur; /* Bt usage time during acl coexistence
+ u32 aclBtMediumDur; /* Bt usage time during acl coexistence
(default 30 msecs)
*/
- A_UINT32 aclDetectTimeout; /* BT activity observation time limit.
+ u32 aclDetectTimeout; /* BT activity observation time limit.
In this time duration, number of bt pkts are counted.
If the Cnt reaches "aclPktCntLowerLimit" value
for "aclIterToEnableCoex" iteration continuously,
-default 100 msecs
*/
- A_UINT32 aclPktCntLowerLimit; /* Acl Pkt Cnt to be received in duration of
+ u32 aclPktCntLowerLimit; /* Acl Pkt Cnt to be received in duration of
"aclDetectTimeout" for
"aclIterForEnDis" times to enabling ACL coex.
Similar logic is used to disable acl coexistence.
default = 10
*/
- A_UINT32 aclIterForEnDis; /* number of Iteration of "aclPktCntLowerLimit" for Enabling and
+ u32 aclIterForEnDis; /* number of Iteration of "aclPktCntLowerLimit" for Enabling and
Disabling Acl Coexistence.
default = 3
*/
- A_UINT32 aclPktCntUpperLimit; /* This is upperBound limit, if there is more than
+ u32 aclPktCntUpperLimit; /* This is upperBound limit, if there is more than
"aclPktCntUpperLimit" seen in "aclDetectTimeout",
ACL coexistence is enabled right away.
- default 15*/
- A_UINT32 aclCoexFlags; /* A2DP Option flags:
+ u32 aclCoexFlags; /* A2DP Option flags:
bits: meaning:
0 Allow Close Range Optimization
1 disable Firmware detection
(Currently supported configuration is aclCoexFlags =0)
*/
- A_UINT32 linkId; /* Applicable only for STE-BT - not used */
+ u32 linkId; /* Applicable only for STE-BT - not used */
}POSTPACK BTCOEX_ACLCOEX_CONFIG;
typedef PREPACK struct {
- A_UINT32 aclDataRespTimeout; /* Max duration firmware waits for downlink
+ u32 aclDataRespTimeout; /* Max duration firmware waits for downlink
by stomping on bluetooth
after ps-poll is acknowledged.
default = 20 ms */
/* Not implemented yet*/
typedef PREPACK struct {
- A_UINT32 aclCoexMinlowRateMbps;
- A_UINT32 aclCoexLowRateCnt;
- A_UINT32 aclCoexHighPktRatio;
- A_UINT32 aclCoexMaxAggrSize;
- A_UINT32 aclPktStompCnt;
+ u32 aclCoexMinlowRateMbps;
+ u32 aclCoexLowRateCnt;
+ u32 aclCoexHighPktRatio;
+ u32 aclCoexMaxAggrSize;
+ u32 aclPktStompCnt;
}POSTPACK BTCOEX_OPTMODE_ACLCOEX_CONFIG;
typedef PREPACK struct {
}WMI_BTCOEX_BT_PROFILE;
typedef PREPACK struct {
- A_UINT32 btProfileType;
- A_UINT32 btOperatingStatus;
- A_UINT32 btLinkId;
+ u32 btProfileType;
+ u32 btOperatingStatus;
+ u32 btLinkId;
}WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMD;
/*--------------------- WMI_SET_BTCOEX_DEBUG_CMDID ---------------------*/
/* Used for firmware development and debugging */
typedef PREPACK struct {
- A_UINT32 btcoexDbgParam1;
- A_UINT32 btcoexDbgParam2;
- A_UINT32 btcoexDbgParam3;
- A_UINT32 btcoexDbgParam4;
- A_UINT32 btcoexDbgParam5;
+ u32 btcoexDbgParam1;
+ u32 btcoexDbgParam2;
+ u32 btcoexDbgParam3;
+ u32 btcoexDbgParam4;
+ u32 btcoexDbgParam5;
}WMI_SET_BTCOEX_DEBUG_CMD;
/*---------------------WMI_GET_BTCOEX_CONFIG_CMDID --------------------- */
/* Command to firmware to get configuration parameters of the bt profile
* reported via WMI_BTCOEX_CONFIG_EVENTID */
typedef PREPACK struct {
- A_UINT32 btProfileType; /* 1 - SCO
+ u32 btProfileType; /* 1 - SCO
2 - A2DP
3 - INQUIRY_PAGE
4 - ACLCOEX
*/
- A_UINT32 linkId; /* not used */
+ u32 linkId; /* not used */
}WMI_GET_BTCOEX_CONFIG_CMD;
/*------------------WMI_REPORT_BTCOEX_CONFIG_EVENTID------------------- */
/* Event from firmware to host, sent in response to WMI_GET_BTCOEX_CONFIG_CMDID
* */
typedef PREPACK struct {
- A_UINT32 btProfileType;
- A_UINT32 linkId; /* not used */
+ u32 btProfileType;
+ u32 linkId; /* not used */
PREPACK union {
WMI_SET_BTCOEX_SCO_CONFIG_CMD scoConfigCmd;
WMI_SET_BTCOEX_A2DP_CONFIG_CMD a2dpConfigCmd;
/*------------- WMI_REPORT_BTCOEX_BTCOEX_STATS_EVENTID--------------------*/
/* Used for firmware development and debugging*/
typedef PREPACK struct {
- A_UINT32 highRatePktCnt;
- A_UINT32 firstBmissCnt;
- A_UINT32 psPollFailureCnt;
- A_UINT32 nullFrameFailureCnt;
- A_UINT32 optModeTransitionCnt;
+ u32 highRatePktCnt;
+ u32 firstBmissCnt;
+ u32 psPollFailureCnt;
+ u32 nullFrameFailureCnt;
+ u32 optModeTransitionCnt;
}BTCOEX_GENERAL_STATS;
typedef PREPACK struct {
- A_UINT32 scoStompCntAvg;
- A_UINT32 scoStompIn100ms;
- A_UINT32 scoMaxContStomp;
- A_UINT32 scoAvgNoRetries;
- A_UINT32 scoMaxNoRetriesIn100ms;
+ u32 scoStompCntAvg;
+ u32 scoStompIn100ms;
+ u32 scoMaxContStomp;
+ u32 scoAvgNoRetries;
+ u32 scoMaxNoRetriesIn100ms;
}BTCOEX_SCO_STATS;
typedef PREPACK struct {
- A_UINT32 a2dpBurstCnt;
- A_UINT32 a2dpMaxBurstCnt;
- A_UINT32 a2dpAvgIdletimeIn100ms;
- A_UINT32 a2dpAvgStompCnt;
+ u32 a2dpBurstCnt;
+ u32 a2dpMaxBurstCnt;
+ u32 a2dpAvgIdletimeIn100ms;
+ u32 a2dpAvgStompCnt;
}BTCOEX_A2DP_STATS;
typedef PREPACK struct {
- A_UINT32 aclPktCntInBtTime;
- A_UINT32 aclStompCntInWlanTime;
- A_UINT32 aclPktCntIn100ms;
+ u32 aclPktCntInBtTime;
+ u32 aclStompCntInWlanTime;
+ u32 aclPktCntIn100ms;
}BTCOEX_ACLCOEX_STATS;
typedef PREPACK struct {
/*--------------------------END OF BTCOEX -------------------------------------*/
typedef PREPACK struct {
- A_UINT32 sleepState;
+ u32 sleepState;
}WMI_REPORT_SLEEP_STATE_EVENT;
typedef enum {
} TARGET_EVENT_REPORT_CONFIG;
typedef PREPACK struct {
- A_UINT32 evtConfig;
+ u32 evtConfig;
} POSTPACK WMI_SET_TARGET_EVENT_REPORT_CMD;
} POSTPACK WMI_READY_EVENT_1;
typedef PREPACK struct {
- A_UINT32 sw_version;
- A_UINT32 abi_version;
+ u32 sw_version;
+ u32 abi_version;
u8 macaddr[ATH_MAC_LEN];
u8 phyCapability; /* WMI_PHY_CAPABILITY */
} POSTPACK WMI_READY_EVENT_2;
u8 bssid[ATH_MAC_LEN];
u16 listenInterval;
u16 beaconInterval;
- A_UINT32 networkType;
+ u32 networkType;
u8 beaconIeLen;
u8 assocReqLen;
u8 assocRespLen;
u8 snr;
A_INT16 rssi;
u8 bssid[ATH_MAC_LEN];
- A_UINT32 ieMask;
+ u32 ieMask;
} POSTPACK WMI_BSS_INFO_HDR;
/*
* New Regulatory Domain Event
*/
typedef PREPACK struct {
- A_UINT32 regDomain;
+ u32 regDomain;
} POSTPACK WMI_REG_DOMAIN_EVENT;
typedef PREPACK struct {
* Reporting statistics.
*/
typedef PREPACK struct {
- A_UINT32 tx_packets;
- A_UINT32 tx_bytes;
- A_UINT32 tx_unicast_pkts;
- A_UINT32 tx_unicast_bytes;
- A_UINT32 tx_multicast_pkts;
- A_UINT32 tx_multicast_bytes;
- A_UINT32 tx_broadcast_pkts;
- A_UINT32 tx_broadcast_bytes;
- A_UINT32 tx_rts_success_cnt;
- A_UINT32 tx_packet_per_ac[4];
- A_UINT32 tx_errors_per_ac[4];
-
- A_UINT32 tx_errors;
- A_UINT32 tx_failed_cnt;
- A_UINT32 tx_retry_cnt;
- A_UINT32 tx_mult_retry_cnt;
- A_UINT32 tx_rts_fail_cnt;
+ u32 tx_packets;
+ u32 tx_bytes;
+ u32 tx_unicast_pkts;
+ u32 tx_unicast_bytes;
+ u32 tx_multicast_pkts;
+ u32 tx_multicast_bytes;
+ u32 tx_broadcast_pkts;
+ u32 tx_broadcast_bytes;
+ u32 tx_rts_success_cnt;
+ u32 tx_packet_per_ac[4];
+ u32 tx_errors_per_ac[4];
+
+ u32 tx_errors;
+ u32 tx_failed_cnt;
+ u32 tx_retry_cnt;
+ u32 tx_mult_retry_cnt;
+ u32 tx_rts_fail_cnt;
A_INT32 tx_unicast_rate;
}POSTPACK tx_stats_t;
typedef PREPACK struct {
- A_UINT32 rx_packets;
- A_UINT32 rx_bytes;
- A_UINT32 rx_unicast_pkts;
- A_UINT32 rx_unicast_bytes;
- A_UINT32 rx_multicast_pkts;
- A_UINT32 rx_multicast_bytes;
- A_UINT32 rx_broadcast_pkts;
- A_UINT32 rx_broadcast_bytes;
- A_UINT32 rx_fragment_pkt;
-
- A_UINT32 rx_errors;
- A_UINT32 rx_crcerr;
- A_UINT32 rx_key_cache_miss;
- A_UINT32 rx_decrypt_err;
- A_UINT32 rx_duplicate_frames;
+ u32 rx_packets;
+ u32 rx_bytes;
+ u32 rx_unicast_pkts;
+ u32 rx_unicast_bytes;
+ u32 rx_multicast_pkts;
+ u32 rx_multicast_bytes;
+ u32 rx_broadcast_pkts;
+ u32 rx_broadcast_bytes;
+ u32 rx_fragment_pkt;
+
+ u32 rx_errors;
+ u32 rx_crcerr;
+ u32 rx_key_cache_miss;
+ u32 rx_decrypt_err;
+ u32 rx_duplicate_frames;
A_INT32 rx_unicast_rate;
}POSTPACK rx_stats_t;
typedef PREPACK struct {
- A_UINT32 tkip_local_mic_failure;
- A_UINT32 tkip_counter_measures_invoked;
- A_UINT32 tkip_replays;
- A_UINT32 tkip_format_errors;
- A_UINT32 ccmp_format_errors;
- A_UINT32 ccmp_replays;
+ u32 tkip_local_mic_failure;
+ u32 tkip_counter_measures_invoked;
+ u32 tkip_replays;
+ u32 tkip_format_errors;
+ u32 ccmp_format_errors;
+ u32 ccmp_replays;
}POSTPACK tkip_ccmp_stats_t;
typedef PREPACK struct {
- A_UINT32 power_save_failure_cnt;
+ u32 power_save_failure_cnt;
u16 stop_tx_failure_cnt;
u16 atim_tx_failure_cnt;
u16 atim_rx_failure_cnt;
}POSTPACK pm_stats_t;
typedef PREPACK struct {
- A_UINT32 cs_bmiss_cnt;
- A_UINT32 cs_lowRssi_cnt;
+ u32 cs_bmiss_cnt;
+ u32 cs_lowRssi_cnt;
u16 cs_connect_cnt;
u16 cs_disconnect_cnt;
A_INT16 cs_aveBeacon_rssi;
}POSTPACK wlan_net_stats_t;
typedef PREPACK struct {
- A_UINT32 arp_received;
- A_UINT32 arp_matched;
- A_UINT32 arp_replied;
+ u32 arp_received;
+ u32 arp_matched;
+ u32 arp_replied;
} POSTPACK arp_stats_t;
typedef PREPACK struct {
- A_UINT32 wow_num_pkts_dropped;
+ u32 wow_num_pkts_dropped;
u16 wow_num_events_discarded;
u8 wow_num_host_pkt_wakeups;
u8 wow_num_host_event_wakeups;
} POSTPACK wlan_wow_stats_t;
typedef PREPACK struct {
- A_UINT32 lqVal;
+ u32 lqVal;
A_INT32 noise_floor_calibation;
pm_stats_t pmStats;
wlan_net_stats_t txrxStats;
} WMI_TARGET_ERROR_VAL;
typedef PREPACK struct {
- A_UINT32 errorVal;
+ u32 errorVal;
}POSTPACK WMI_TARGET_ERROR_REPORT_EVENT;
typedef PREPACK struct {
*
* Get fix rates cmd uses same definition as set fix rates cmd
*/
-#define FIX_RATE_1Mb ((A_UINT32)0x1)
-#define FIX_RATE_2Mb ((A_UINT32)0x2)
-#define FIX_RATE_5_5Mb ((A_UINT32)0x4)
-#define FIX_RATE_11Mb ((A_UINT32)0x8)
-#define FIX_RATE_6Mb ((A_UINT32)0x10)
-#define FIX_RATE_9Mb ((A_UINT32)0x20)
-#define FIX_RATE_12Mb ((A_UINT32)0x40)
-#define FIX_RATE_18Mb ((A_UINT32)0x80)
-#define FIX_RATE_24Mb ((A_UINT32)0x100)
-#define FIX_RATE_36Mb ((A_UINT32)0x200)
-#define FIX_RATE_48Mb ((A_UINT32)0x400)
-#define FIX_RATE_54Mb ((A_UINT32)0x800)
-#define FIX_RATE_MCS_0_20 ((A_UINT32)0x1000)
-#define FIX_RATE_MCS_1_20 ((A_UINT32)0x2000)
-#define FIX_RATE_MCS_2_20 ((A_UINT32)0x4000)
-#define FIX_RATE_MCS_3_20 ((A_UINT32)0x8000)
-#define FIX_RATE_MCS_4_20 ((A_UINT32)0x10000)
-#define FIX_RATE_MCS_5_20 ((A_UINT32)0x20000)
-#define FIX_RATE_MCS_6_20 ((A_UINT32)0x40000)
-#define FIX_RATE_MCS_7_20 ((A_UINT32)0x80000)
-#define FIX_RATE_MCS_0_40 ((A_UINT32)0x100000)
-#define FIX_RATE_MCS_1_40 ((A_UINT32)0x200000)
-#define FIX_RATE_MCS_2_40 ((A_UINT32)0x400000)
-#define FIX_RATE_MCS_3_40 ((A_UINT32)0x800000)
-#define FIX_RATE_MCS_4_40 ((A_UINT32)0x1000000)
-#define FIX_RATE_MCS_5_40 ((A_UINT32)0x2000000)
-#define FIX_RATE_MCS_6_40 ((A_UINT32)0x4000000)
-#define FIX_RATE_MCS_7_40 ((A_UINT32)0x8000000)
-
-typedef PREPACK struct {
- A_UINT32 fixRateMask; /* see WMI_BIT_RATE */
+#define FIX_RATE_1Mb ((u32)0x1)
+#define FIX_RATE_2Mb ((u32)0x2)
+#define FIX_RATE_5_5Mb ((u32)0x4)
+#define FIX_RATE_11Mb ((u32)0x8)
+#define FIX_RATE_6Mb ((u32)0x10)
+#define FIX_RATE_9Mb ((u32)0x20)
+#define FIX_RATE_12Mb ((u32)0x40)
+#define FIX_RATE_18Mb ((u32)0x80)
+#define FIX_RATE_24Mb ((u32)0x100)
+#define FIX_RATE_36Mb ((u32)0x200)
+#define FIX_RATE_48Mb ((u32)0x400)
+#define FIX_RATE_54Mb ((u32)0x800)
+#define FIX_RATE_MCS_0_20 ((u32)0x1000)
+#define FIX_RATE_MCS_1_20 ((u32)0x2000)
+#define FIX_RATE_MCS_2_20 ((u32)0x4000)
+#define FIX_RATE_MCS_3_20 ((u32)0x8000)
+#define FIX_RATE_MCS_4_20 ((u32)0x10000)
+#define FIX_RATE_MCS_5_20 ((u32)0x20000)
+#define FIX_RATE_MCS_6_20 ((u32)0x40000)
+#define FIX_RATE_MCS_7_20 ((u32)0x80000)
+#define FIX_RATE_MCS_0_40 ((u32)0x100000)
+#define FIX_RATE_MCS_1_40 ((u32)0x200000)
+#define FIX_RATE_MCS_2_40 ((u32)0x400000)
+#define FIX_RATE_MCS_3_40 ((u32)0x800000)
+#define FIX_RATE_MCS_4_40 ((u32)0x1000000)
+#define FIX_RATE_MCS_5_40 ((u32)0x2000000)
+#define FIX_RATE_MCS_6_40 ((u32)0x4000000)
+#define FIX_RATE_MCS_7_40 ((u32)0x8000000)
+
+typedef PREPACK struct {
+ u32 fixRateMask; /* see WMI_BIT_RATE */
} POSTPACK WMI_FIX_RATES_CMD, WMI_FIX_RATES_REPLY;
typedef PREPACK struct {
u8 bEnableMask;
u8 frameType; /*type and subtype*/
- A_UINT32 frameRateMask; /* see WMI_BIT_RATE */
+ u32 frameRateMask; /* see WMI_BIT_RATE */
} POSTPACK WMI_FRAME_RATES_CMD, WMI_FRAME_RATES_REPLY;
/*
} ROAM_DATA_TYPE;
typedef PREPACK struct {
- A_UINT32 disassoc_time;
- A_UINT32 no_txrx_time;
- A_UINT32 assoc_time;
- A_UINT32 allow_txrx_time;
+ u32 disassoc_time;
+ u32 no_txrx_time;
+ u32 assoc_time;
+ u32 allow_txrx_time;
u8 disassoc_bssid[ATH_MAC_LEN];
A_INT8 disassoc_bss_rssi;
u8 assoc_bssid[ATH_MAC_LEN];
#define MAX_IP_ADDRS 2
typedef PREPACK struct {
- A_UINT32 ips[MAX_IP_ADDRS]; /* IP in Network Byte Order */
+ u32 ips[MAX_IP_ADDRS]; /* IP in Network Byte Order */
} POSTPACK WMI_SET_IP_CMD;
typedef PREPACK struct {
#define WMI_AKMP_MULTI_PMKID_EN 0x000001
typedef PREPACK struct {
- A_UINT32 akmpInfo;
+ u32 akmpInfo;
} POSTPACK WMI_SET_AKMP_PARAMS_CMD;
typedef PREPACK struct {
#define WMI_MAX_PMKID_CACHE 8
typedef PREPACK struct {
- A_UINT32 numPMKID;
+ u32 numPMKID;
WMI_PMKID pmkidList[WMI_MAX_PMKID_CACHE];
} POSTPACK WMI_SET_PMKID_LIST_CMD;
* Following the Number of PMKIDs is the list of PMKIDs
*/
typedef PREPACK struct {
- A_UINT32 numPMKID;
+ u32 numPMKID;
u8 bssidList[ATH_MAC_LEN][1];
WMI_PMKID pmkidList[1];
} POSTPACK WMI_PMKID_LIST_REPLY;
typedef PREPACK struct {
u16 oldChannel;
- A_UINT32 newChannel;
+ u32 newChannel;
} POSTPACK WMI_CHANNEL_CHANGE_EVENT;
typedef PREPACK struct {
- A_UINT32 version;
+ u32 version;
} POSTPACK WMI_WLAN_VERSION_EVENT;
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
+ u32 queueDelay; // usec delay measured Tx Start time - host delivery time
+ u32 mediaDelay; // usec delay measured ACK rx time - host delivery time
#endif
} POSTPACK TX_COMPLETE_MSG_V1; /* version 1 of tx complete msg */
} POSTPACK WMI_AP_SET_MLME_CMD;
typedef PREPACK struct {
- A_UINT32 period;
+ u32 period;
} POSTPACK WMI_AP_CONN_INACT_CMD;
typedef PREPACK struct {
- A_UINT32 period_min;
- A_UINT32 dwell_ms;
+ u32 period_min;
+ u32 dwell_ms;
} POSTPACK WMI_AP_PROT_SCAN_TIME_CMD;
typedef PREPACK struct {
} POSTPACK WMI_SET_HT_OP_CMD;
typedef PREPACK struct {
- A_UINT32 rateMasks[8];
+ u32 rateMasks[8];
} POSTPACK WMI_SET_TX_SELECT_RATES_CMD;
typedef PREPACK struct {
- A_UINT32 sgiMask;
+ u32 sgiMask;
u8 sgiPERThreshold;
} POSTPACK WMI_SET_TX_SGI_PARAM_CMD;
#define DEFAULT_SGI_PER 10
typedef PREPACK struct {
- A_UINT32 rateField; /* 1 bit per rate corresponding to index */
+ u32 rateField; /* 1 bit per rate corresponding to index */
u8 id;
u8 shortTrys;
u8 longTrys;
} POSTPACK WMI_PSPOLL_EVENT;
typedef PREPACK struct {
- A_UINT32 tx_bytes;
- A_UINT32 tx_pkts;
- A_UINT32 tx_error;
- A_UINT32 tx_discard;
- A_UINT32 rx_bytes;
- A_UINT32 rx_pkts;
- A_UINT32 rx_error;
- A_UINT32 rx_discard;
- A_UINT32 aid;
+ u32 tx_bytes;
+ u32 tx_pkts;
+ u32 tx_error;
+ u32 tx_discard;
+ u32 rx_bytes;
+ u32 rx_pkts;
+ u32 rx_error;
+ u32 rx_discard;
+ u32 aid;
} POSTPACK WMI_PER_STA_STAT;
#define AP_GET_STATS 0
#define AP_CLEAR_STATS 1
typedef PREPACK struct {
- A_UINT32 action;
+ u32 action;
WMI_PER_STA_STAT sta[AP_MAX_NUM_STA+1];
} POSTPACK WMI_AP_MODE_STAT;
-#define WMI_AP_MODE_STAT_SIZE(numSta) (sizeof(A_UINT32) + ((numSta + 1) * sizeof(WMI_PER_STA_STAT)))
+#define WMI_AP_MODE_STAT_SIZE(numSta) (sizeof(u32) + ((numSta + 1) * sizeof(WMI_PER_STA_STAT)))
#define AP_11BG_RATESET1 1
#define AP_11BG_RATESET2 2
* frames that require partial MAC header construction. These rules
* are used by the target to indicate which fields need to be written. */
typedef PREPACK struct {
- A_UINT32 rules; /* combination of WMI_WRT_... values */
+ u32 rules; /* combination of WMI_WRT_... values */
} POSTPACK WMI_THIN_CONFIG_TX_MAC_RULES;
/* WMI_THIN_CONFIG_RX_FILTER_RULES -- Used to configure behavior for received
* frames as to which frames should get forwarded to the host and which
* should get processed internally. */
typedef PREPACK struct {
- A_UINT32 rules; /* combination of WMI_FILT_... values */
+ u32 rules; /* combination of WMI_FILT_... values */
} POSTPACK WMI_THIN_CONFIG_RX_FILTER_RULES;
/* WMI_THIN_CONFIG_CMD -- Used to contain some combination of the above
#define WMI_THIN_CFG_DECRYPT 0x00000002
#define WMI_THIN_CFG_MAC_RULES 0x00000004
#define WMI_THIN_CFG_FILTER_RULES 0x00000008
- A_UINT32 cfgField; /* combination of WMI_THIN_CFG_... describes contents of config command */
+ u32 cfgField; /* combination of WMI_THIN_CFG_... describes contents of config command */
u16 length; /* length in bytes of appended sub-commands */
u8 reserved[2]; /* align padding */
} POSTPACK WMI_THIN_CONFIG_CMD;
} POSTPACK WMI_THIN_MIB_STA_MAC;
typedef PREPACK struct {
- A_UINT32 time; // units == msec
+ u32 time; // units == msec
} POSTPACK WMI_THIN_MIB_RX_LIFE_TIME;
typedef PREPACK struct {
} POSTPACK WMI_THIN_MIB_CTS_TO_SELF;
typedef PREPACK struct {
- A_UINT32 time; // units == usec
+ u32 time; // units == usec
} POSTPACK WMI_THIN_MIB_SLOT_TIME;
typedef PREPACK struct {
typedef PREPACK struct {
#define FRAME_FILTER_PROMISCUOUS 0x00000001
#define FRAME_FILTER_BSSID 0x00000002
- A_UINT32 filterMask;
+ u32 filterMask;
} POSTPACK WMI_THIN_MIB_RXFRAME_FILTER;
} POSTPACK WMI_THIN_MIB_BEACON_FILTER_TABLE_HEADER;
typedef PREPACK struct {
- A_UINT32 count; /* num beacons between deliveries */
+ u32 count; /* num beacons between deliveries */
u8 enable;
u8 reserved[3];
} POSTPACK WMI_THIN_MIB_BEACON_FILTER;
typedef PREPACK struct {
- A_UINT32 count; /* num consec lost beacons after which send event */
+ u32 count; /* num consec lost beacons after which send event */
} POSTPACK WMI_THIN_MIB_BEACON_LOST_COUNT;
typedef PREPACK struct {
typedef PREPACK struct {
- A_UINT32 cap;
- A_UINT32 rxRateField;
- A_UINT32 beamForming;
+ u32 cap;
+ u32 rxRateField;
+ u32 beamForming;
u8 addr[ATH_MAC_LEN];
u8 enable;
u8 stbc;
} POSTPACK WMI_THIN_MIB_HT_CAP;
typedef PREPACK struct {
- A_UINT32 infoField;
- A_UINT32 basicRateField;
+ u32 infoField;
+ u32 basicRateField;
u8 protection;
u8 secondChanneloffset;
u8 channelWidth;
} POSTPACK WMI_THIN_GET_MIB_CMD;
typedef PREPACK struct {
- A_UINT32 basicRateMask; /* bit mask of basic rates */
- A_UINT32 beaconIntval; /* TUs */
+ u32 basicRateMask; /* bit mask of basic rates */
+ u32 beaconIntval; /* TUs */
u16 atimWindow; /* TUs */
u16 channel; /* frequency in Mhz */
u8 networkType; /* INFRA_NETWORK | ADHOC_NETWORK */
* WMI_EVENT_ID=WMI_EXTENSION_EVENTID.
*/
typedef PREPACK struct {
- A_UINT32 commandId;
+ u32 commandId;
} POSTPACK WMIX_CMD_HDR;
typedef enum {
* DataSet Open Request Event
*/
typedef PREPACK struct {
- A_UINT32 dset_id;
- A_UINT32 targ_dset_handle; /* echo'ed, not used by Host, */
- A_UINT32 targ_reply_fn; /* echo'ed, not used by Host, */
- A_UINT32 targ_reply_arg; /* echo'ed, not used by Host, */
+ u32 dset_id;
+ u32 targ_dset_handle; /* echo'ed, not used by Host, */
+ u32 targ_reply_fn; /* echo'ed, not used by Host, */
+ u32 targ_reply_arg; /* echo'ed, not used by Host, */
} POSTPACK WMIX_DSETOPENREQ_EVENT;
/*
* DataSet Close Event
*/
typedef PREPACK struct {
- A_UINT32 access_cookie;
+ u32 access_cookie;
} POSTPACK WMIX_DSETCLOSE_EVENT;
/*
* DataSet Data Request Event
*/
typedef PREPACK struct {
- A_UINT32 access_cookie;
- A_UINT32 offset;
- A_UINT32 length;
- A_UINT32 targ_buf; /* echo'ed, not used by Host, */
- A_UINT32 targ_reply_fn; /* echo'ed, not used by Host, */
- A_UINT32 targ_reply_arg; /* echo'ed, not used by Host, */
+ u32 access_cookie;
+ u32 offset;
+ u32 length;
+ u32 targ_buf; /* echo'ed, not used by Host, */
+ u32 targ_reply_fn; /* echo'ed, not used by Host, */
+ u32 targ_reply_arg; /* echo'ed, not used by Host, */
} POSTPACK WMIX_DSETDATAREQ_EVENT;
typedef PREPACK struct {
- A_UINT32 status;
- A_UINT32 targ_dset_handle;
- A_UINT32 targ_reply_fn;
- A_UINT32 targ_reply_arg;
- A_UINT32 access_cookie;
- A_UINT32 size;
- A_UINT32 version;
+ u32 status;
+ u32 targ_dset_handle;
+ u32 targ_reply_fn;
+ u32 targ_reply_arg;
+ u32 access_cookie;
+ u32 size;
+ u32 version;
} POSTPACK WMIX_DSETOPEN_REPLY_CMD;
typedef PREPACK struct {
- A_UINT32 status;
- A_UINT32 targ_buf;
- A_UINT32 targ_reply_fn;
- A_UINT32 targ_reply_arg;
- A_UINT32 length;
+ u32 status;
+ u32 targ_buf;
+ u32 targ_reply_fn;
+ u32 targ_reply_arg;
+ u32 length;
u8 buf[1];
} POSTPACK WMIX_DSETDATA_REPLY_CMD;
* clear/disable or disable/enable, results are undefined.
*/
typedef PREPACK struct {
- A_UINT32 set_mask; /* pins to set */
- A_UINT32 clear_mask; /* pins to clear */
- A_UINT32 enable_mask; /* pins to enable for output */
- A_UINT32 disable_mask; /* pins to disable/tristate */
+ u32 set_mask; /* pins to set */
+ u32 clear_mask; /* pins to clear */
+ u32 enable_mask; /* pins to enable for output */
+ u32 disable_mask; /* pins to disable/tristate */
} POSTPACK WMIX_GPIO_OUTPUT_SET_CMD;
/*
* platform-dependent header.
*/
typedef PREPACK struct {
- A_UINT32 gpioreg_id; /* GPIO register ID */
- A_UINT32 value; /* value to write */
+ u32 gpioreg_id; /* GPIO register ID */
+ u32 value; /* value to write */
} POSTPACK WMIX_GPIO_REGISTER_SET_CMD;
/* Get a GPIO register. For debug/exceptional cases. */
typedef PREPACK struct {
- A_UINT32 gpioreg_id; /* GPIO register to read */
+ u32 gpioreg_id; /* GPIO register to read */
} POSTPACK WMIX_GPIO_REGISTER_GET_CMD;
/*
* were delivered in an earlier WMIX_GPIO_INTR_EVENT message.
*/
typedef PREPACK struct {
- A_UINT32 ack_mask; /* interrupts to acknowledge */
+ u32 ack_mask; /* interrupts to acknowledge */
} POSTPACK WMIX_GPIO_INTR_ACK_CMD;
/*
* use of a GPIO interrupt as a Data Valid signal for other GPIO pins.
*/
typedef PREPACK struct {
- A_UINT32 intr_mask; /* pending GPIO interrupts */
- A_UINT32 input_values; /* recent GPIO input values */
+ u32 intr_mask; /* pending GPIO interrupts */
+ u32 input_values; /* recent GPIO input values */
} POSTPACK WMIX_GPIO_INTR_EVENT;
/*
* simplify Host GPIO support.
*/
typedef PREPACK struct {
- A_UINT32 value;
- A_UINT32 reg_id;
+ u32 value;
+ u32 reg_id;
} POSTPACK WMIX_GPIO_DATA_EVENT;
/*
* Heartbeat Challenge Response command
*/
typedef PREPACK struct {
- A_UINT32 cookie;
- A_UINT32 source;
+ u32 cookie;
+ u32 source;
} POSTPACK WMIX_HB_CHALLENGE_RESP_CMD;
/*
*/
typedef PREPACK struct {
- A_UINT32 period; /* Time (in 30.5us ticks) between samples */
- A_UINT32 nbins;
+ u32 period; /* Time (in 30.5us ticks) between samples */
+ u32 nbins;
} POSTPACK WMIX_PROF_CFG_CMD;
typedef PREPACK struct {
- A_UINT32 addr;
+ u32 addr;
} POSTPACK WMIX_PROF_ADDR_SET_CMD;
/*
* count set to the corresponding count
*/
typedef PREPACK struct {
- A_UINT32 addr;
- A_UINT32 count;
+ u32 addr;
+ u32 count;
} POSTPACK WMIX_PROF_COUNT_EVENT;
#ifndef ATH_TARGET
/* OS-independent APIs */
int ar6000_setup_credit_dist(HTC_HANDLE HTCHandle, COMMON_CREDIT_STATE_INFO *pCredInfo);
-int ar6000_ReadRegDiag(HIF_DEVICE *hifDevice, A_UINT32 *address, A_UINT32 *data);
+int ar6000_ReadRegDiag(HIF_DEVICE *hifDevice, u32 *address, u32 *data);
-int ar6000_WriteRegDiag(HIF_DEVICE *hifDevice, A_UINT32 *address, A_UINT32 *data);
+int ar6000_WriteRegDiag(HIF_DEVICE *hifDevice, u32 *address, u32 *data);
-int ar6000_ReadDataDiag(HIF_DEVICE *hifDevice, A_UINT32 address, A_UCHAR *data, A_UINT32 length);
+int ar6000_ReadDataDiag(HIF_DEVICE *hifDevice, u32 address, A_UCHAR *data, u32 length);
-int ar6000_reset_device(HIF_DEVICE *hifDevice, A_UINT32 TargetType, bool waitForCompletion, bool coldReset);
+int ar6000_reset_device(HIF_DEVICE *hifDevice, u32 TargetType, bool waitForCompletion, bool coldReset);
-void ar6000_dump_target_assert_info(HIF_DEVICE *hifDevice, A_UINT32 TargetType);
+void ar6000_dump_target_assert_info(HIF_DEVICE *hifDevice, u32 TargetType);
int ar6000_set_htc_params(HIF_DEVICE *hifDevice,
- A_UINT32 TargetType,
- A_UINT32 MboxIsrYieldValue,
+ u32 TargetType,
+ u32 MboxIsrYieldValue,
u8 HtcControlBuffers);
int ar6000_prepare_target(HIF_DEVICE *hifDevice,
- A_UINT32 TargetType,
- A_UINT32 TargetVersion);
+ u32 TargetType,
+ u32 TargetVersion);
int ar6000_set_hci_bridge_flags(HIF_DEVICE *hifDevice,
- A_UINT32 TargetType,
- A_UINT32 Flags);
+ u32 TargetType,
+ u32 Flags);
-void ar6000_copy_cust_data_from_target(HIF_DEVICE *hifDevice, A_UINT32 TargetType);
+void ar6000_copy_cust_data_from_target(HIF_DEVICE *hifDevice, u32 TargetType);
-u8 *ar6000_get_cust_data_buffer(A_UINT32 TargetType);
+u8 *ar6000_get_cust_data_buffer(u32 TargetType);
-int ar6000_setBTState(void *context, u8 *pInBuf, A_UINT32 InBufSize);
+int ar6000_setBTState(void *context, u8 *pInBuf, u32 InBufSize);
-int ar6000_setDevicePowerState(void *context, u8 *pInBuf, A_UINT32 InBufSize);
+int ar6000_setDevicePowerState(void *context, u8 *pInBuf, u32 InBufSize);
-int ar6000_setWowMode(void *context, u8 *pInBuf, A_UINT32 InBufSize);
+int ar6000_setWowMode(void *context, u8 *pInBuf, u32 InBufSize);
-int ar6000_setHostMode(void *context, u8 *pInBuf, A_UINT32 InBufSize);
+int ar6000_setHostMode(void *context, u8 *pInBuf, u32 InBufSize);
#ifdef __cplusplus
}
/* Called to send a DataSet Open Reply back to the Target. */
int wmi_dset_open_reply(struct wmi_t *wmip,
- A_UINT32 status,
- A_UINT32 access_cookie,
- A_UINT32 size,
- A_UINT32 version,
- A_UINT32 targ_handle,
- A_UINT32 targ_reply_fn,
- A_UINT32 targ_reply_arg);
+ u32 status,
+ u32 access_cookie,
+ u32 size,
+ u32 version,
+ u32 targ_handle,
+ u32 targ_reply_fn,
+ u32 targ_reply_arg);
/* Called to send a DataSet Data Reply back to the Target. */
int wmi_dset_data_reply(struct wmi_t *wmip,
- A_UINT32 status,
+ u32 status,
u8 *host_buf,
- A_UINT32 length,
- A_UINT32 targ_buf,
- A_UINT32 targ_reply_fn,
- A_UINT32 targ_reply_arg);
+ u32 length,
+ u32 targ_buf,
+ u32 targ_reply_fn,
+ u32 targ_reply_arg);
#ifdef __cplusplus
}
* Send a command to the Target in order to change output on GPIO pins.
*/
int wmi_gpio_output_set(struct wmi_t *wmip,
- A_UINT32 set_mask,
- A_UINT32 clear_mask,
- A_UINT32 enable_mask,
- A_UINT32 disable_mask);
+ u32 set_mask,
+ u32 clear_mask,
+ u32 enable_mask,
+ u32 disable_mask);
/*
* Send a command to the Target requesting input state of GPIO pins.
* Send a command to the Target to change the value of a GPIO register.
*/
int wmi_gpio_register_set(struct wmi_t *wmip,
- A_UINT32 gpioreg_id,
- A_UINT32 value);
+ u32 gpioreg_id,
+ u32 value);
/*
* Send a command to the Target to fetch the value of a GPIO register.
*/
-int wmi_gpio_register_get(struct wmi_t *wmip, A_UINT32 gpioreg_id);
+int wmi_gpio_register_get(struct wmi_t *wmip, u32 gpioreg_id);
/*
* Send a command to the Target, acknowledging some GPIO interrupts.
*/
-int wmi_gpio_intr_ack(struct wmi_t *wmip, A_UINT32 ack_mask);
+int wmi_gpio_intr_ack(struct wmi_t *wmip, u32 ack_mask);
#endif /* _GPIO_API_H_ */
@example:
@see also:
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-int HCI_TransportSetBaudRate(HCI_TRANSPORT_HANDLE HciTrans, A_UINT32 Baud);
+int HCI_TransportSetBaudRate(HCI_TRANSPORT_HANDLE HciTrans, u32 Baud);
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@desc: Enable/Disable HCI Transport Power Management
*/
typedef struct {
- A_UINT32 ExtendedAddress; /* extended address for larger writes */
- A_UINT32 ExtendedSize;
+ u32 ExtendedAddress; /* extended address for larger writes */
+ u32 ExtendedSize;
} HIF_MBOX_PROPERTIES;
#define HIF_MBOX_FLAG_NO_BUNDLING (1 << 0) /* do not allow bundling over the mailbox */
} MBOX_BUF_IF_TYPE;
typedef struct {
- A_UINT32 MboxAddresses[4]; /* must be first element for legacy HIFs that return the address in
+ u32 MboxAddresses[4]; /* must be first element for legacy HIFs that return the address in
and ARRAY of 32-bit words */
/* the following describe extended mailbox properties */
HIF_MBOX_PROPERTIES MboxProp[4];
/* if the HIF supports the GMbox extended address region it can report it
* here, some interfaces cannot support the GMBOX address range and not set this */
- A_UINT32 GMboxAddress;
- A_UINT32 GMboxSize;
- A_UINT32 Flags; /* flags to describe mbox behavior or usage */
+ u32 GMboxAddress;
+ u32 GMboxSize;
+ u32 Flags; /* flags to describe mbox behavior or usage */
MBOX_BUF_IF_TYPE MboxBusIFType; /* mailbox bus interface type */
} HIF_DEVICE_MBOX_INFO;
typedef struct _HIF_SCATTER_REQ {
DL_LIST ListLink; /* link management */
- A_UINT32 Address; /* address for the read/write operation */
- A_UINT32 Request; /* request flags */
- A_UINT32 TotalLength; /* total length of entire transfer */
- A_UINT32 CallerFlags; /* caller specific flags can be stored here */
+ u32 Address; /* address for the read/write operation */
+ u32 Request; /* request flags */
+ u32 TotalLength; /* total length of entire transfer */
+ u32 CallerFlags; /* caller specific flags can be stored here */
HIF_SCATTER_COMP_CB CompletionRoutine; /* completion routine set by caller */
int CompletionStatus; /* status of completion */
void *Context; /* caller context for this request */
#define HIF_RECV_MSG_AVAIL (1 << 1) /* pending recv packet */
typedef struct _HIF_PENDING_EVENTS_INFO {
- A_UINT32 Events;
- A_UINT32 LookAhead;
- A_UINT32 AvailableRecvBytes;
+ u32 Events;
+ u32 LookAhead;
+ u32 AvailableRecvBytes;
#ifdef THREAD_X
- A_UINT32 Polling;
- A_UINT32 INT_CAUSE_REG;
+ u32 Polling;
+ u32 INT_CAUSE_REG;
#endif
} HIF_PENDING_EVENTS_INFO;
*/
int
HIFReadWrite(HIF_DEVICE *device,
- A_UINT32 address,
+ u32 address,
A_UCHAR *buffer,
- A_UINT32 length,
- A_UINT32 request,
+ u32 length,
+ u32 request,
void *context);
/*
int
HIFConfigureDevice(HIF_DEVICE *device, HIF_DEVICE_CONFIG_OPCODE opcode,
- void *config, A_UINT32 configLen);
+ void *config, u32 configLen);
/*
* This API wait for the remaining MBOX messages to be drained
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 */
+ u32 LocalConnectionFlags; /* HTC flags for the host-side (local) connection */
unsigned int MaxSendMsgSize; /* override max message size in send direction */
} HTC_SERVICE_CONNECT_REQ;
struct _HTC_ENDPOINT_CREDIT_DIST *pPrev;
HTC_SERVICE_ID ServiceID; /* Service ID (set by HTC) */
HTC_ENDPOINT_ID Endpoint; /* endpoint for this distribution struct (set by HTC) */
- A_UINT32 DistFlags; /* distribution flags, distribution function can
+ u32 DistFlags; /* distribution flags, distribution function can
set default activity using SET_EP_ACTIVE() macro */
int TxCreditsNorm; /* credits for normal operation, anything above this
indicates the endpoint is over-subscribed, this field
*/
} HTC_ENDPOINT_CREDIT_DIST;
-#define HTC_EP_ACTIVE ((A_UINT32) (1u << 31))
+#define HTC_EP_ACTIVE ((u32) (1u << 31))
/* macro to check if an endpoint has gone active, useful for credit
* distributions */
/* endpoint statistics */
typedef struct _HTC_ENDPOINT_STATS {
- A_UINT32 TxCreditLowIndications; /* number of times the host set the credit-low flag in a send message on
+ u32 TxCreditLowIndications; /* number of times the host set the credit-low flag in a send message on
this endpoint */
- A_UINT32 TxIssued; /* running count of total TX packets issued */
- A_UINT32 TxPacketsBundled; /* running count of TX packets that were issued in bundles */
- A_UINT32 TxBundles; /* running count of TX bundles that were issued */
- A_UINT32 TxDropped; /* tx packets that were dropped */
- A_UINT32 TxCreditRpts; /* running count of total credit reports received for this endpoint */
- A_UINT32 TxCreditRptsFromRx; /* credit reports received from this endpoint's RX packets */
- A_UINT32 TxCreditRptsFromOther; /* credit reports received from RX packets of other endpoints */
- A_UINT32 TxCreditRptsFromEp0; /* credit reports received from endpoint 0 RX packets */
- A_UINT32 TxCreditsFromRx; /* count of credits received via Rx packets on this endpoint */
- A_UINT32 TxCreditsFromOther; /* count of credits received via another endpoint */
- A_UINT32 TxCreditsFromEp0; /* count of credits received via another endpoint */
- A_UINT32 TxCreditsConsummed; /* count of consummed credits */
- A_UINT32 TxCreditsReturned; /* count of credits returned */
- A_UINT32 RxReceived; /* count of RX packets received */
- A_UINT32 RxLookAheads; /* count of lookahead records
+ u32 TxIssued; /* running count of total TX packets issued */
+ u32 TxPacketsBundled; /* running count of TX packets that were issued in bundles */
+ u32 TxBundles; /* running count of TX bundles that were issued */
+ u32 TxDropped; /* tx packets that were dropped */
+ u32 TxCreditRpts; /* running count of total credit reports received for this endpoint */
+ u32 TxCreditRptsFromRx; /* credit reports received from this endpoint's RX packets */
+ u32 TxCreditRptsFromOther; /* credit reports received from RX packets of other endpoints */
+ u32 TxCreditRptsFromEp0; /* credit reports received from endpoint 0 RX packets */
+ u32 TxCreditsFromRx; /* count of credits received via Rx packets on this endpoint */
+ u32 TxCreditsFromOther; /* count of credits received via another endpoint */
+ u32 TxCreditsFromEp0; /* count of credits received via another endpoint */
+ u32 TxCreditsConsummed; /* count of consummed credits */
+ u32 TxCreditsReturned; /* count of credits returned */
+ u32 RxReceived; /* count of RX packets received */
+ u32 RxLookAheads; /* count of lookahead records
found in messages received on this endpoint */
- A_UINT32 RxPacketsBundled; /* count of recv packets received in a bundle */
- A_UINT32 RxBundleLookAheads; /* count of number of bundled lookaheads */
- A_UINT32 RxBundleIndFromHdr; /* count of the number of bundle indications from the HTC header */
- A_UINT32 RxAllocThreshHit; /* count of the number of times the recv allocation threshhold was hit */
- A_UINT32 RxAllocThreshBytes; /* total number of bytes */
+ u32 RxPacketsBundled; /* count of recv packets received in a bundle */
+ u32 RxBundleLookAheads; /* count of number of bundled lookaheads */
+ u32 RxBundleIndFromHdr; /* count of the number of bundle indications from the HTC header */
+ u32 RxAllocThreshHit; /* count of the number of times the recv allocation threshhold was hit */
+ u32 RxAllocThreshBytes; /* total number of bytes */
} HTC_ENDPOINT_STATS;
/* ------ Function Prototypes ------ */
void HTCEnableRecv(HTC_HANDLE HTCHandle);
void HTCDisableRecv(HTC_HANDLE HTCHandle);
int HTCWaitForPendingRecv(HTC_HANDLE HTCHandle,
- A_UINT32 TimeoutInMs,
+ u32 TimeoutInMs,
bool *pbIsRecvPending);
#ifdef __cplusplus
#define HTC_TX_PACKET_TAG_USER_DEFINED (HTC_TX_PACKET_TAG_INTERNAL + 9) /* user-defined tags start here */
typedef struct _HTC_RX_PACKET_INFO {
- A_UINT32 ExpectedHdr; /* HTC internal use */
- A_UINT32 HTCRxFlags; /* HTC internal use */
- A_UINT32 IndicationFlags; /* indication flags set on each RX packet indication */
+ u32 ExpectedHdr; /* HTC internal use */
+ u32 HTCRxFlags; /* HTC internal use */
+ u32 IndicationFlags; /* indication flags set on each RX packet indication */
} HTC_RX_PACKET_INFO;
#define HTC_RX_FLAGS_INDICATE_MORE_PKTS (1 << 0) /* more packets on this endpoint are being fetched */
* to the caller points to the start of the payload
*/
u8 *pBuffer; /* payload start (RX/TX) */
- A_UINT32 BufferLength; /* length of buffer */
- A_UINT32 ActualLength; /* actual length of payload */
+ u32 BufferLength; /* length of buffer */
+ u32 ActualLength; /* actual length of payload */
HTC_ENDPOINT_ID Endpoint; /* endpoint that this packet was sent/recv'd from */
int Status; /* completion status */
union {
/*** WARNING : Add to the end of the TABLE! do not change the order ****/
typedef struct targetdef_s {
- A_UINT32 d_RTC_BASE_ADDRESS;
- A_UINT32 d_SYSTEM_SLEEP_OFFSET;
- A_UINT32 d_SYSTEM_SLEEP_DISABLE_LSB;
- A_UINT32 d_SYSTEM_SLEEP_DISABLE_MASK;
- A_UINT32 d_CLOCK_CONTROL_OFFSET;
- A_UINT32 d_CLOCK_CONTROL_SI0_CLK_MASK;
- A_UINT32 d_RESET_CONTROL_OFFSET;
- A_UINT32 d_RESET_CONTROL_SI0_RST_MASK;
- A_UINT32 d_GPIO_BASE_ADDRESS;
- A_UINT32 d_GPIO_PIN0_OFFSET;
- A_UINT32 d_GPIO_PIN1_OFFSET;
- A_UINT32 d_GPIO_PIN0_CONFIG_MASK;
- A_UINT32 d_GPIO_PIN1_CONFIG_MASK;
- A_UINT32 d_SI_CONFIG_BIDIR_OD_DATA_LSB;
- A_UINT32 d_SI_CONFIG_BIDIR_OD_DATA_MASK;
- A_UINT32 d_SI_CONFIG_I2C_LSB;
- A_UINT32 d_SI_CONFIG_I2C_MASK;
- A_UINT32 d_SI_CONFIG_POS_SAMPLE_LSB;
- A_UINT32 d_SI_CONFIG_POS_SAMPLE_MASK;
- A_UINT32 d_SI_CONFIG_INACTIVE_CLK_LSB;
- A_UINT32 d_SI_CONFIG_INACTIVE_CLK_MASK;
- A_UINT32 d_SI_CONFIG_INACTIVE_DATA_LSB;
- A_UINT32 d_SI_CONFIG_INACTIVE_DATA_MASK;
- A_UINT32 d_SI_CONFIG_DIVIDER_LSB;
- A_UINT32 d_SI_CONFIG_DIVIDER_MASK;
- A_UINT32 d_SI_BASE_ADDRESS;
- A_UINT32 d_SI_CONFIG_OFFSET;
- A_UINT32 d_SI_TX_DATA0_OFFSET;
- A_UINT32 d_SI_TX_DATA1_OFFSET;
- A_UINT32 d_SI_RX_DATA0_OFFSET;
- A_UINT32 d_SI_RX_DATA1_OFFSET;
- A_UINT32 d_SI_CS_OFFSET;
- A_UINT32 d_SI_CS_DONE_ERR_MASK;
- A_UINT32 d_SI_CS_DONE_INT_MASK;
- A_UINT32 d_SI_CS_START_LSB;
- A_UINT32 d_SI_CS_START_MASK;
- A_UINT32 d_SI_CS_RX_CNT_LSB;
- A_UINT32 d_SI_CS_RX_CNT_MASK;
- A_UINT32 d_SI_CS_TX_CNT_LSB;
- A_UINT32 d_SI_CS_TX_CNT_MASK;
- A_UINT32 d_BOARD_DATA_SZ;
- A_UINT32 d_BOARD_EXT_DATA_SZ;
+ u32 d_RTC_BASE_ADDRESS;
+ u32 d_SYSTEM_SLEEP_OFFSET;
+ u32 d_SYSTEM_SLEEP_DISABLE_LSB;
+ u32 d_SYSTEM_SLEEP_DISABLE_MASK;
+ u32 d_CLOCK_CONTROL_OFFSET;
+ u32 d_CLOCK_CONTROL_SI0_CLK_MASK;
+ u32 d_RESET_CONTROL_OFFSET;
+ u32 d_RESET_CONTROL_SI0_RST_MASK;
+ u32 d_GPIO_BASE_ADDRESS;
+ u32 d_GPIO_PIN0_OFFSET;
+ u32 d_GPIO_PIN1_OFFSET;
+ u32 d_GPIO_PIN0_CONFIG_MASK;
+ u32 d_GPIO_PIN1_CONFIG_MASK;
+ u32 d_SI_CONFIG_BIDIR_OD_DATA_LSB;
+ u32 d_SI_CONFIG_BIDIR_OD_DATA_MASK;
+ u32 d_SI_CONFIG_I2C_LSB;
+ u32 d_SI_CONFIG_I2C_MASK;
+ u32 d_SI_CONFIG_POS_SAMPLE_LSB;
+ u32 d_SI_CONFIG_POS_SAMPLE_MASK;
+ u32 d_SI_CONFIG_INACTIVE_CLK_LSB;
+ u32 d_SI_CONFIG_INACTIVE_CLK_MASK;
+ u32 d_SI_CONFIG_INACTIVE_DATA_LSB;
+ u32 d_SI_CONFIG_INACTIVE_DATA_MASK;
+ u32 d_SI_CONFIG_DIVIDER_LSB;
+ u32 d_SI_CONFIG_DIVIDER_MASK;
+ u32 d_SI_BASE_ADDRESS;
+ u32 d_SI_CONFIG_OFFSET;
+ u32 d_SI_TX_DATA0_OFFSET;
+ u32 d_SI_TX_DATA1_OFFSET;
+ u32 d_SI_RX_DATA0_OFFSET;
+ u32 d_SI_RX_DATA1_OFFSET;
+ u32 d_SI_CS_OFFSET;
+ u32 d_SI_CS_DONE_ERR_MASK;
+ u32 d_SI_CS_DONE_INT_MASK;
+ u32 d_SI_CS_START_LSB;
+ u32 d_SI_CS_START_MASK;
+ u32 d_SI_CS_RX_CNT_LSB;
+ u32 d_SI_CS_RX_CNT_MASK;
+ u32 d_SI_CS_TX_CNT_LSB;
+ u32 d_SI_CS_TX_CNT_MASK;
+ u32 d_BOARD_DATA_SZ;
+ u32 d_BOARD_EXT_DATA_SZ;
} TARGET_REGISTER_TABLE;
#define BOARD_DATA_SZ_MAX 2048
u8 *ni_buf;
u16 ni_framelen;
struct ieee80211_node_table *ni_table;
- A_UINT32 ni_refcnt;
+ u32 ni_refcnt;
int ni_scangen;
- A_UINT32 ni_tstamp;
- A_UINT32 ni_actcnt;
+ u32 ni_tstamp;
+ u32 ni_actcnt;
#ifdef OS_ROAM_MANAGEMENT
- A_UINT32 ni_si_gen;
+ u32 ni_si_gen;
#endif
} bss_t;
struct ieee80211_common_ie *cie);
u16 wlan_ieee2freq(int chan);
-A_UINT32 wlan_freq2ieee(u16 freq);
+u32 wlan_freq2ieee(u16 freq);
-void wlan_set_nodeage(struct ieee80211_node_table *nt, A_UINT32 nodeAge);
+void wlan_set_nodeage(struct ieee80211_node_table *nt, u32 nodeAge);
void
wlan_refresh_inactive_nodes (struct ieee80211_node_table *nt);
bss_t *
wlan_find_Ssidnode (struct ieee80211_node_table *nt, A_UCHAR *pSsid,
- A_UINT32 ssidLength, bool bIsWPA2, bool bMatchSSID);
+ u32 ssidLength, bool bIsWPA2, bool bMatchSSID);
void
wlan_node_return (struct ieee80211_node_table *nt, bss_t *ni);
bss_t *
wlan_find_matching_Ssidnode (struct ieee80211_node_table *nt, A_UCHAR *pSsid,
- A_UINT32 ssidLength, A_UINT32 dot11AuthMode, A_UINT32 authMode,
- A_UINT32 pairwiseCryptoType, A_UINT32 grpwiseCryptoTyp);
+ u32 ssidLength, u32 dot11AuthMode, u32 authMode,
+ u32 pairwiseCryptoType, u32 grpwiseCryptoTyp);
#ifdef __cplusplus
}
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);
-u8 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, u32 layer2Priority, bool wmmEnabled);
-u8 wmi_determine_userPriority (u8 *pkt, A_UINT32 layer2Pri);
+u8 wmi_determine_userPriority (u8 *pkt, u32 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);
A_UCHAR *ssid,
u8 *bssid,
u16 channel,
- A_UINT32 ctrl_flags);
+ u32 ctrl_flags);
int wmi_reconnect_cmd(struct wmi_t *wmip,
u8 *bssid,
int wmi_getrev_cmd(struct wmi_t *wmip);
int wmi_startscan_cmd(struct wmi_t *wmip, WMI_SCAN_TYPE scanType,
u32 forceFgScan, u32 isLegacy,
- A_UINT32 homeDwellTime, A_UINT32 forceScanInterval,
+ u32 homeDwellTime, u32 forceScanInterval,
A_INT8 numChan, u16 *channelList);
int wmi_scanparams_cmd(struct wmi_t *wmip, u16 fg_start_sec,
u16 fg_end_sec, u16 bg_sec,
u16 minact_chdw_msec,
u16 maxact_chdw_msec, u16 pas_chdw_msec,
u8 shScanRatio, u8 scanCtrlFlags,
- A_UINT32 max_dfsch_act_time,
+ u32 max_dfsch_act_time,
u16 maxact_scan_per_ssid);
-int wmi_bssfilter_cmd(struct wmi_t *wmip, u8 filter, A_UINT32 ieMask);
+int wmi_bssfilter_cmd(struct wmi_t *wmip, u8 filter, u32 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, u16 listenInterval, u16 listenBeacons);
int wmi_powermode_cmd(struct wmi_t *wmip, u8 powerMode);
int wmi_ibsspmcaps_cmd(struct wmi_t *wmip, u8 pmEnable, u8 ttl,
u16 atim_windows, u16 timeout_value);
-int wmi_apps_cmd(struct wmi_t *wmip, u8 psType, A_UINT32 idle_time,
- A_UINT32 ps_period, u8 sleep_period);
+int wmi_apps_cmd(struct wmi_t *wmip, u8 psType, u32 idle_time,
+ u32 ps_period, u8 sleep_period);
int wmi_pmparams_cmd(struct wmi_t *wmip, u16 idlePeriod,
u16 psPollNum, u16 dtimPolicy,
u16 wakup_tx_policy, u16 num_tx_to_wakeup,
int wmi_set_rts_cmd(struct wmi_t *wmip, u16 threshold);
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_set_error_report_bitmask(struct wmi_t *wmip, u32 bitmask);
-int wmi_get_challenge_resp_cmd(struct wmi_t *wmip, A_UINT32 cookie,
- A_UINT32 source);
+int wmi_get_challenge_resp_cmd(struct wmi_t *wmip, u32 cookie,
+ u32 source);
int wmi_config_debug_module_cmd(struct wmi_t *wmip, u16 mmask,
u16 tsr, bool rep, u16 size,
- A_UINT32 valid);
+ u32 valid);
int wmi_get_stats_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, u8 *buf, A_UINT32 len);
+int wmi_test_cmd(struct wmi_t *wmip, u8 *buf, u32 len);
#endif
int wmi_set_bt_status_cmd(struct wmi_t *wmip, u8 streamType, u8 status);
int wmi_get_btcoex_stats_cmd(struct wmi_t * wmip);
-int wmi_SGI_cmd(struct wmi_t *wmip, A_UINT32 sgiMask, u8 sgiPERThreshold);
+int wmi_SGI_cmd(struct wmi_t *wmip, u32 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_set_fixrates_cmd(struct wmi_t *wmip, u32 fixRatesMask);
int wmi_get_ratemask_cmd(struct wmi_t *wmip);
int wmi_set_authmode_cmd(struct wmi_t *wmip, u8 mode);
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);
+int wmi_set_wsc_status_cmd(struct wmi_t *wmip, u32 status);
int
-wmi_set_params_cmd(struct wmi_t *wmip, A_UINT32 opcode, A_UINT32 length, char *buffer);
+wmi_set_params_cmd(struct wmi_t *wmip, u32 opcode, u32 length, char *buffer);
int
wmi_set_mcast_filter_cmd(struct wmi_t *wmip, u8 dot1, u8 dot2, u8 dot3, u8 dot4);
bss_t *
wmi_find_Ssidnode (struct wmi_t *wmip, A_UCHAR *pSsid,
- A_UINT32 ssidLength, bool bIsWPA2, bool bMatchSSID);
+ u32 ssidLength, bool bIsWPA2, bool bMatchSSID);
void
wmi_node_return (struct wmi_t *wmip, bss_t *bss);
void
-wmi_set_nodeage(struct wmi_t *wmip, A_UINT32 nodeAge);
+wmi_set_nodeage(struct wmi_t *wmip, u32 nodeAge);
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
-int wmi_prof_cfg_cmd(struct wmi_t *wmip, A_UINT32 period, A_UINT32 nbins);
-int wmi_prof_addr_set_cmd(struct wmi_t *wmip, A_UINT32 addr);
+int wmi_prof_cfg_cmd(struct wmi_t *wmip, u32 period, u32 nbins);
+int wmi_prof_addr_set_cmd(struct wmi_t *wmip, u32 addr);
int wmi_prof_start_cmd(struct wmi_t *wmip);
int wmi_prof_stop_cmd(struct wmi_t *wmip);
int wmi_prof_count_get_cmd(struct wmi_t *wmip);
wmi_set_pvb_cmd(struct wmi_t *wmip, u16 aid, bool flag);
int
-wmi_ap_conn_inact_time(struct wmi_t *wmip, A_UINT32 period);
+wmi_ap_conn_inact_time(struct wmi_t *wmip, u32 period);
int
-wmi_ap_bgscan_time(struct wmi_t *wmip, A_UINT32 period, A_UINT32 dwell);
+wmi_ap_bgscan_time(struct wmi_t *wmip, u32 period, u32 dwell);
int
wmi_ap_set_dtim(struct wmi_t *wmip, u8 dtim);
wmi_send_hci_cmd(struct wmi_t *wmip, u8 *buf, u16 sz);
int
-wmi_set_tx_select_rates_cmd(struct wmi_t *wmip, A_UINT32 *pMaskArray);
+wmi_set_tx_select_rates_cmd(struct wmi_t *wmip, u32 *pMaskArray);
int
wmi_setup_aggr_cmd(struct wmi_t *wmip, u8 tid);
u16 wmi_ieee2freq (int chan);
-A_UINT32
-wmi_freq2ieee (u16 freq);
+u32 wmi_freq2ieee (u16 freq);
bss_t *
wmi_find_matching_Ssidnode (struct wmi_t *wmip, A_UCHAR *pSsid,
- A_UINT32 ssidLength,
- A_UINT32 dot11AuthMode, A_UINT32 authMode,
- A_UINT32 pairwiseCryptoType, A_UINT32 grpwiseCryptoTyp);
+ u32 ssidLength,
+ u32 dot11AuthMode, u32 authMode,
+ u32 pairwiseCryptoType, u32 grpwiseCryptoTyp);
#ifdef __cplusplus
}
typedef struct {
PSCmdPacket *HciCmdList;
- A_UINT32 num_packets;
+ u32 num_packets;
AR3K_CONFIG_INFO *dev;
}HciCommandListParam;
u8 **ppEventBuffer,
u8 **ppBufferToFree);
-A_UINT32 Rom_Version;
-A_UINT32 Build_Version;
+u32 Rom_Version;
+u32 Build_Version;
extern bool BDADDR;
-int getDeviceType(AR3K_CONFIG_INFO *pConfig, A_UINT32 * code);
+int getDeviceType(AR3K_CONFIG_INFO *pConfig, u32 *code);
int ReadVersionInfo(AR3K_CONFIG_INFO *pConfig);
#ifndef HCI_TRANSPORT_SDIO
rwlock_t syncLock;
wait_queue_t Eventwait;
-int PSHciWritepacket(struct hci_dev*,A_UCHAR* Data, A_UINT32 len);
+int PSHciWritepacket(struct hci_dev*,A_UCHAR* Data, u32 len);
extern char *bdaddr;
#endif /* HCI_TRANSPORT_SDIO */
int PSSendOps(void *arg);
#ifdef BT_PS_DEBUG
-void Hci_log(A_UCHAR * log_string,A_UCHAR *data,A_UINT32 len)
+void Hci_log(A_UCHAR * log_string,A_UCHAR *data,u32 len)
{
int i;
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s : ",log_string));
int status = 0;
PSCmdPacket *HciCmdList; /* List storing the commands */
const struct firmware* firmware;
- A_UINT32 numCmds;
+ u32 numCmds;
u8 *event;
u8 *bufferToFree;
struct hci_dev *device;
A_UCHAR *buffer;
- A_UINT32 len;
- A_UINT32 DevType;
+ u32 len;
+ u32 DevType;
A_UCHAR *PsFileName;
A_UCHAR *patchFileName;
A_UCHAR *path = NULL;
}
return result;
}
-int getDeviceType(AR3K_CONFIG_INFO *pConfig, A_UINT32 * code)
+int getDeviceType(AR3K_CONFIG_INFO *pConfig, u32 *code)
{
u8 hciCommand[] = {0x05,0xfc,0x05,0x00,0x00,0x00,0x00,0x04};
u8 *event;
u8 *bufferToFree = NULL;
- A_UINT32 reg;
+ u32 reg;
int result = A_ERROR;
*code = 0;
hciCommand[3] = (u8)(FPGA_REGISTER & 0xFF);
typedef struct tPsTagEntry
{
- A_UINT32 TagId;
- A_UINT32 TagLen;
+ u32 TagId;
+ u32 TagLen;
u8 *TagData;
} tPsTagEntry, *tpPsTagEntry;
/* Stores the number of PS Tags */
-static A_UINT32 Tag_Count = 0;
+static u32 Tag_Count = 0;
/* Stores the number of patch commands */
-static A_UINT32 Patch_Count = 0;
-static A_UINT32 Total_tag_lenght = 0;
+static u32 Patch_Count = 0;
+static u32 Total_tag_lenght = 0;
bool BDADDR = false;
-A_UINT32 StartTagId;
+u32 StartTagId;
tPsTagEntry PsTagEntry[RAMPS_MAX_PS_TAGS_PER_FILE];
tRamPatch RamPatch[MAX_NUM_PATCH_ENTRY];
-int AthParseFilesUnified(A_UCHAR *srcbuffer,A_UINT32 srclen, int FileFormat);
-char AthReadChar(A_UCHAR *buffer, A_UINT32 len,A_UINT32 *pos);
-char *AthGetLine(char *buffer, int maxlen, A_UCHAR *srcbuffer,A_UINT32 len,A_UINT32 *pos);
-static int AthPSCreateHCICommand(A_UCHAR Opcode, A_UINT32 Param1,PSCmdPacket *PSPatchPacket,A_UINT32 *index);
+int AthParseFilesUnified(A_UCHAR *srcbuffer,u32 srclen, int FileFormat);
+char AthReadChar(A_UCHAR *buffer, u32 len,u32 *pos);
+char *AthGetLine(char *buffer, int maxlen, A_UCHAR *srcbuffer,u32 len,u32 *pos);
+static int AthPSCreateHCICommand(A_UCHAR Opcode, u32 Param1,PSCmdPacket *PSPatchPacket,u32 *index);
/* Function to reads the next character from the input buffer */
-char AthReadChar(A_UCHAR *buffer, A_UINT32 len,A_UINT32 *pos)
+char AthReadChar(A_UCHAR *buffer, u32 len,u32 *pos)
{
char Ch;
if(buffer == NULL || *pos >=len )
return (0x0FFF);
}
}
-int AthParseFilesUnified(A_UCHAR *srcbuffer,A_UINT32 srclen, int FileFormat)
+int AthParseFilesUnified(A_UCHAR *srcbuffer,u32 srclen, int FileFormat)
{
char *Buffer;
char *pCharLine;
u8 TagCount;
u16 ByteCount;
u8 ParseSection=RAM_PS_SECTION;
- A_UINT32 pos;
+ u32 pos;
/********************/
-int GetNextTwoChar(A_UCHAR *srcbuffer,A_UINT32 len, A_UINT32 *pos, char *buffer)
+int GetNextTwoChar(A_UCHAR *srcbuffer,u32 len, u32 *pos, char *buffer)
{
unsigned char ch;
return A_OK;
}
-int AthDoParsePatch(A_UCHAR *patchbuffer, A_UINT32 patchlen)
+int AthDoParsePatch(A_UCHAR *patchbuffer, u32 patchlen)
{
char Byte[3];
int count;
int i,j,k;
int data;
- A_UINT32 filepos;
+ u32 filepos;
Byte[2] = '\0';
j = 0;
filepos = 0;
/********************/
-int AthDoParsePS(A_UCHAR *srcbuffer, A_UINT32 srclen)
+int AthDoParsePS(A_UCHAR *srcbuffer, u32 srclen)
{
int status;
int i;
return status;
}
-char *AthGetLine(char *buffer, int maxlen, A_UCHAR *srcbuffer,A_UINT32 len,A_UINT32 *pos)
+char *AthGetLine(char *buffer, int maxlen, A_UCHAR *srcbuffer,u32 len,u32 *pos)
{
int count;
/////////////////////////
//
-int AthCreateCommandList(PSCmdPacket **HciPacketList, A_UINT32 *numPackets)
+int AthCreateCommandList(PSCmdPacket **HciPacketList, u32 *numPackets)
{
u8 count;
- A_UINT32 NumcmdEntry = 0;
+ u32 NumcmdEntry = 0;
- A_UINT32 Crc = 0;
+ u32 Crc = 0;
*numPackets = 0;
if(Patch_Count > 0) {
NumcmdEntry++; /* Patch Enable Command */
}
- AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Num Cmd Entries %d Size %d \r\n",NumcmdEntry,(A_UINT32)sizeof(PSCmdPacket) * NumcmdEntry));
+ AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Num Cmd Entries %d Size %d \r\n",NumcmdEntry,(u32)sizeof(PSCmdPacket) * NumcmdEntry));
(*HciPacketList) = A_MALLOC(sizeof(PSCmdPacket) * NumcmdEntry);
if(NULL == *HciPacketList) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("memory allocation failed \r\n"));
////////////////////////
/////////////
-static int AthPSCreateHCICommand(A_UCHAR Opcode, A_UINT32 Param1,PSCmdPacket *PSPatchPacket,A_UINT32 *index)
+static int AthPSCreateHCICommand(A_UCHAR Opcode, u32 Param1,PSCmdPacket *PSPatchPacket,u32 *index)
{
A_UCHAR *HCI_PS_Command;
- A_UINT32 Length;
+ u32 Length;
int i,j;
switch(Opcode)
}
return A_OK;
}
-int AthFreeCommandList(PSCmdPacket **HciPacketList, A_UINT32 numPackets)
+int AthFreeCommandList(PSCmdPacket **HciPacketList, u32 numPackets)
{
int i;
if(*HciPacketList == NULL) {
/* Helper data type declaration */
-#ifndef A_UINT32
-#define A_UCHAR unsigned char
-#define A_UINT32 unsigned long
+#ifndef u32 #define A_UCHAR unsigned char
+#define u32 unsigned long
#define u16 unsigned short
#define u8 unsigned char
#define bool unsigned char
-#endif /* A_UINT32 */
+#endif /* u32 */
#define ATH_DEBUG_ERR (1 << 0)
#define ATH_DEBUG_WARN (1 << 1)
} PSCmdPacket;
/* Parses a Patch information buffer and store it in global structure */
-int AthDoParsePatch(A_UCHAR *, A_UINT32);
+int AthDoParsePatch(A_UCHAR *, u32 );
/* parses a PS information buffer and stores it in a global structure */
-int AthDoParsePS(A_UCHAR *, A_UINT32);
+int AthDoParsePS(A_UCHAR *, u32 );
/*
* Uses the output of Both AthDoParsePS and AthDoParsePatch APIs to form HCI command array with
* PS Tag Command(s)
*
*/
-int AthCreateCommandList(PSCmdPacket **, A_UINT32 *);
+int AthCreateCommandList(PSCmdPacket **, u32 *);
/* Cleanup the dynamically allicated HCI command list */
-int AthFreeCommandList(PSCmdPacket **HciPacketList, A_UINT32 numPackets);
+int AthFreeCommandList(PSCmdPacket **HciPacketList, u32 numPackets);
#endif /* __AR3KPSPARSER_H */
#ifdef USE_4BYTE_REGISTER_ACCESS
/* set the window address register (using 4-byte register access ). */
-int ar6000_SetAddressWindowRegister(HIF_DEVICE *hifDevice, A_UINT32 RegisterAddr, A_UINT32 Address)
+int ar6000_SetAddressWindowRegister(HIF_DEVICE *hifDevice, u32 RegisterAddr, u32 Address)
{
int status;
u8 addrValue[4];
#else
/* set the window address register */
-int ar6000_SetAddressWindowRegister(HIF_DEVICE *hifDevice, A_UINT32 RegisterAddr, A_UINT32 Address)
+int ar6000_SetAddressWindowRegister(HIF_DEVICE *hifDevice, u32 RegisterAddr, u32 Address)
{
int status;
status = HIFReadWrite(hifDevice,
RegisterAddr+1, /* write upper 3 bytes */
((A_UCHAR *)(&Address))+1,
- sizeof(A_UINT32)-1,
+ sizeof(u32)-1,
HIF_WR_SYNC_BYTE_INC,
NULL);
* No cooperation from the Target is required for this.
*/
int
-ar6000_ReadRegDiag(HIF_DEVICE *hifDevice, A_UINT32 *address, A_UINT32 *data)
+ar6000_ReadRegDiag(HIF_DEVICE *hifDevice, u32 *address, u32 *data)
{
int status;
status = HIFReadWrite(hifDevice,
WINDOW_DATA_ADDRESS,
(A_UCHAR *)data,
- sizeof(A_UINT32),
+ sizeof(u32),
HIF_RD_SYNC_BYTE_INC,
NULL);
if (status != A_OK) {
* No cooperation from the Target is required for this.
*/
int
-ar6000_WriteRegDiag(HIF_DEVICE *hifDevice, A_UINT32 *address, A_UINT32 *data)
+ar6000_WriteRegDiag(HIF_DEVICE *hifDevice, u32 *address, u32 *data)
{
int status;
status = HIFReadWrite(hifDevice,
WINDOW_DATA_ADDRESS,
(A_UCHAR *)data,
- sizeof(A_UINT32),
+ sizeof(u32),
HIF_WR_SYNC_BYTE_INC,
NULL);
if (status != A_OK) {
}
int
-ar6000_ReadDataDiag(HIF_DEVICE *hifDevice, A_UINT32 address,
- A_UCHAR *data, A_UINT32 length)
+ar6000_ReadDataDiag(HIF_DEVICE *hifDevice, u32 address,
+ A_UCHAR *data, u32 length)
{
- A_UINT32 count;
+ u32 count;
int status = A_OK;
for (count = 0; count < length; count += 4, address += 4) {
if ((status = ar6000_ReadRegDiag(hifDevice, &address,
- (A_UINT32 *)&data[count])) != A_OK)
+ (u32 *)&data[count])) != A_OK)
{
break;
}
}
int
-ar6000_WriteDataDiag(HIF_DEVICE *hifDevice, A_UINT32 address,
- A_UCHAR *data, A_UINT32 length)
+ar6000_WriteDataDiag(HIF_DEVICE *hifDevice, u32 address,
+ A_UCHAR *data, u32 length)
{
- A_UINT32 count;
+ u32 count;
int status = A_OK;
for (count = 0; count < length; count += 4, address += 4) {
if ((status = ar6000_WriteRegDiag(hifDevice, &address,
- (A_UINT32 *)&data[count])) != A_OK)
+ (u32 *)&data[count])) != A_OK)
{
break;
}
}
int
-ar6k_ReadTargetRegister(HIF_DEVICE *hifDevice, int regsel, A_UINT32 *regval)
+ar6k_ReadTargetRegister(HIF_DEVICE *hifDevice, int regsel, u32 *regval)
{
int status;
A_UCHAR vals[4];
}
void
-ar6k_FetchTargetRegs(HIF_DEVICE *hifDevice, A_UINT32 *targregs)
+ar6k_FetchTargetRegs(HIF_DEVICE *hifDevice, u32 *targregs)
{
int i;
- A_UINT32 val;
+ u32 val;
for (i=0; i<AR6003_FETCH_TARG_REGS_COUNT; i++) {
val=0xffffffff;
#if 0
static int
-_do_write_diag(HIF_DEVICE *hifDevice, A_UINT32 addr, A_UINT32 value)
+_do_write_diag(HIF_DEVICE *hifDevice, u32 addr, u32 value)
{
int status;
*/
#if 0
static int
-_delay_until_target_alive(HIF_DEVICE *hifDevice, A_INT32 wait_msecs, A_UINT32 TargetType)
+_delay_until_target_alive(HIF_DEVICE *hifDevice, A_INT32 wait_msecs, u32 TargetType)
{
A_INT32 actual_wait;
A_INT32 i;
- A_UINT32 address;
+ u32 address;
actual_wait = 0;
}
address += 0x10;
for (i=0; actual_wait < wait_msecs; i++) {
- A_UINT32 data;
+ u32 data;
A_MDELAY(100);
actual_wait += 100;
#define AR6002_RESET_CONTROL_ADDRESS 0x00004000
#define AR6003_RESET_CONTROL_ADDRESS 0x00004000
/* reset device */
-int ar6000_reset_device(HIF_DEVICE *hifDevice, A_UINT32 TargetType, bool waitForCompletion, bool coldReset)
+int ar6000_reset_device(HIF_DEVICE *hifDevice, u32 TargetType, bool waitForCompletion, bool coldReset)
{
int status = A_OK;
- A_UINT32 address;
- A_UINT32 data;
+ u32 address;
+ u32 data;
do {
// Workaround BEGIN
/* This should be called in BMI phase after firmware is downloaded */
void
-ar6000_copy_cust_data_from_target(HIF_DEVICE *hifDevice, A_UINT32 TargetType)
+ar6000_copy_cust_data_from_target(HIF_DEVICE *hifDevice, u32 TargetType)
{
- A_UINT32 eepHeaderAddr;
+ u32 eepHeaderAddr;
u8 AR6003CustDataShadow[AR6003_CUST_DATA_SIZE+4];
A_INT32 i;
eepHeaderAddr += 36; /* AR6003 customer data section offset is 37 */
for (i=0; i<AR6003_CUST_DATA_SIZE+4; i+=4){
- if (BMIReadSOCRegister(hifDevice, eepHeaderAddr, (A_UINT32 *)&AR6003CustDataShadow[i])!= A_OK) {
+ if (BMIReadSOCRegister(hifDevice, eepHeaderAddr, (u32 *)&AR6003CustDataShadow[i])!= A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMIReadSOCRegister () failed \n"));
return ;
}
eepHeaderAddr += 64; /* AR6002 customer data sectioin offset is 64 */
for (i=0; i<AR6002_CUST_DATA_SIZE; i+=4){
- if (BMIReadSOCRegister(hifDevice, eepHeaderAddr, (A_UINT32 *)&custDataAR6002[i])!= A_OK) {
+ if (BMIReadSOCRegister(hifDevice, eepHeaderAddr, (u32 *)&custDataAR6002[i])!= A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMIReadSOCRegister () failed \n"));
return ;
}
}
/* This is the function to call when need to use the cust data */
-u8 *ar6000_get_cust_data_buffer(A_UINT32 TargetType)
+u8 *ar6000_get_cust_data_buffer(u32 TargetType)
{
if (TargetType == TARGET_TYPE_AR6003)
return custDataAR6003;
#endif
-void ar6000_dump_target_assert_info(HIF_DEVICE *hifDevice, A_UINT32 TargetType)
+void ar6000_dump_target_assert_info(HIF_DEVICE *hifDevice, u32 TargetType)
{
- A_UINT32 address;
- A_UINT32 regDumpArea = 0;
+ u32 address;
+ u32 regDumpArea = 0;
int status;
- A_UINT32 regDumpValues[REGISTER_DUMP_LEN_MAX];
- A_UINT32 regDumpCount = 0;
- A_UINT32 i;
+ u32 regDumpValues[REGISTER_DUMP_LEN_MAX];
+ u32 regDumpCount = 0;
+ u32 i;
do {
status = ar6000_ReadDataDiag(hifDevice,
regDumpArea,
(A_UCHAR *)®DumpValues[0],
- regDumpCount * (sizeof(A_UINT32)));
+ regDumpCount * (sizeof(u32)));
if (status) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("AR6K: Failed to get register dump \n"));
/* set HTC/Mbox operational parameters, this can only be called when the target is in the
* BMI phase */
int ar6000_set_htc_params(HIF_DEVICE *hifDevice,
- A_UINT32 TargetType,
- A_UINT32 MboxIsrYieldValue,
+ u32 TargetType,
+ u32 MboxIsrYieldValue,
u8 HtcControlBuffers)
{
int status;
- A_UINT32 blocksizes[HTC_MAILBOX_NUM_MAX];
+ u32 blocksizes[HTC_MAILBOX_NUM_MAX];
do {
/* get the block sizes */
if (HtcControlBuffers != 0) {
/* set override for number of control buffers to use */
- blocksizes[1] |= ((A_UINT32)HtcControlBuffers) << 16;
+ blocksizes[1] |= ((u32)HtcControlBuffers) << 16;
}
/* set the host interest area for the block size */
}
-static int prepare_ar6002(HIF_DEVICE *hifDevice, A_UINT32 TargetVersion)
+static int prepare_ar6002(HIF_DEVICE *hifDevice, u32 TargetVersion)
{
int status = A_OK;
return status;
}
-static int prepare_ar6003(HIF_DEVICE *hifDevice, A_UINT32 TargetVersion)
+static int prepare_ar6003(HIF_DEVICE *hifDevice, u32 TargetVersion)
{
int status = A_OK;
/* this function assumes the caller has already initialized the BMI APIs */
int ar6000_prepare_target(HIF_DEVICE *hifDevice,
- A_UINT32 TargetType,
- A_UINT32 TargetVersion)
+ u32 TargetType,
+ u32 TargetVersion)
{
if (TargetType == TARGET_TYPE_AR6002) {
/* do any preparations for AR6002 devices */
{
A_INT32 i;
struct forceROM_s {
- A_UINT32 addr;
- A_UINT32 data;
+ u32 addr;
+ u32 data;
};
struct forceROM_s *ForceROM;
A_INT32 szForceROM;
int status = A_OK;
- A_UINT32 address;
- A_UINT32 data;
+ u32 address;
+ u32 data;
/* Force AR6002 REV1.x to recognize Host presence.
*
{
char stream[60];
char byteOffsetStr[10];
- A_UINT32 i;
+ u32 i;
u16 offset, count, byteOffset;
A_PRINTF("<---------Dumping %d Bytes : %s ------>\n", length, pDescription);
}
-int a_get_module_mask(char *module_name, A_UINT32 *pMask)
+int a_get_module_mask(char *module_name, u32 *pMask)
{
ATH_DEBUG_MODULE_DBG_INFO *pInfo = FindModule(module_name);
return A_OK;
}
-int a_set_module_mask(char *module_name, A_UINT32 Mask)
+int a_set_module_mask(char *module_name, u32 Mask)
{
ATH_DEBUG_MODULE_DBG_INFO *pInfo = FindModule(module_name);
/* can only be called during bmi init stage */
int ar6000_set_hci_bridge_flags(HIF_DEVICE *hifDevice,
- A_UINT32 TargetType,
- A_UINT32 Flags)
+ u32 TargetType,
+ u32 Flags)
{
int status = A_OK;
#define HOST_INTEREST_ITEM_ADDRESS(target, item) \
AR6002_HOST_INTEREST_ITEM_ADDRESS(item)
-A_UINT32 ar6kRev2Array[][128] = {
+u32 ar6kRev2Array[][128] = {
{0xFFFF, 0xFFFF}, // No Patches
};
#define mboxnum &_mboxnum
#ifdef DEBUG
-A_UINT32 g_dbg_flags = DBG_DEFAULTS;
+u32 g_dbg_flags = DBG_DEFAULTS;
unsigned int debugflags = 0;
int debugdriver = 0;
unsigned int debughtc = 0;
A_INT16 bg_param_b;
A_INT16 a_param_a;
A_INT16 a_param_b;
- A_UINT32 reserved;
+ u32 reserved;
} USER_RSSI_CPENSATION;
static USER_RSSI_CPENSATION rssi_compensation_param;
ar6000_sysfs_bmi_deinit(AR_SOFTC_T *ar);
int
-ar6000_sysfs_bmi_get_config(AR_SOFTC_T *ar, A_UINT32 mode);
+ar6000_sysfs_bmi_get_config(AR_SOFTC_T *ar, u32 mode);
/*
* Static variables
int
ar6000_set_host_app_area(AR_SOFTC_T *ar)
{
- A_UINT32 address, data;
+ u32 address, data;
struct host_app_area_s host_app_area;
/* Fetch the address of the host_app_area_s instance in the host interest area */
return A_OK;
}
-A_UINT32
-dbglog_get_debug_hdr_ptr(AR_SOFTC_T *ar)
+u32 dbglog_get_debug_hdr_ptr(AR_SOFTC_T *ar)
{
- A_UINT32 param;
- A_UINT32 address;
+ u32 param;
+ u32 address;
int status;
address = TARG_VTOP(ar->arTargetType, HOST_INTEREST_ITEM_ADDRESS(ar, hi_dbglog_hdr));
ar->dbglog_init_done = true;
}
-A_UINT32
-dbglog_get_debug_fragment(A_INT8 *datap, A_UINT32 len, A_UINT32 limit)
+u32 dbglog_get_debug_fragment(A_INT8 *datap, u32 len, u32 limit)
{
A_INT32 *buffer;
- A_UINT32 count;
- A_UINT32 numargs;
- A_UINT32 length;
- A_UINT32 fraglen;
+ u32 count;
+ u32 numargs;
+ u32 length;
+ u32 fraglen;
count = fraglen = 0;
buffer = (A_INT32 *)datap;
}
void
-dbglog_parse_debug_logs(A_INT8 *datap, A_UINT32 len)
+dbglog_parse_debug_logs(A_INT8 *datap, u32 len)
{
A_INT32 *buffer;
- A_UINT32 count;
- A_UINT32 timestamp;
- A_UINT32 debugid;
- A_UINT32 moduleid;
- A_UINT32 numargs;
- A_UINT32 length;
+ u32 count;
+ u32 timestamp;
+ u32 debugid;
+ u32 moduleid;
+ u32 numargs;
+ u32 length;
count = 0;
buffer = (A_INT32 *)datap;
int
ar6000_dbglog_get_debug_logs(AR_SOFTC_T *ar)
{
- A_UINT32 data[8]; /* Should be able to accomodate struct dbglog_buf_s */
- A_UINT32 address;
- A_UINT32 length;
- A_UINT32 dropped;
- A_UINT32 firstbuf;
- A_UINT32 debug_hdr_ptr;
+ u32 data[8]; /* Should be able to accomodate struct dbglog_buf_s */
+ u32 address;
+ u32 length;
+ u32 dropped;
+ u32 firstbuf;
+ u32 debug_hdr_ptr;
if (!ar->dbglog_init_done) return A_ERROR;
}
void
-ar6000_dbglog_event(AR_SOFTC_T *ar, A_UINT32 dropped,
- A_INT8 *buffer, A_UINT32 length)
+ar6000_dbglog_event(AR_SOFTC_T *ar, u32 dropped,
+ A_INT8 *buffer, u32 length)
{
#ifdef REPORT_DEBUG_LOGS_TO_APP
#define MAX_WIRELESS_EVENT_SIZE 252
* There seems to be a limitation on the length of message that could be
* transmitted to the user app via this mechanism.
*/
- A_UINT32 send, sent;
+ u32 send, sent;
sent = 0;
send = dbglog_get_debug_fragment(&buffer[sent], length - sent,
void
aptcTimerHandler(unsigned long arg)
{
- A_UINT32 numbytes;
- A_UINT32 throughput;
+ u32 numbytes;
+ u32 throughput;
AR_SOFTC_T *ar;
int status;
AR_SOFTC_T *ar;
HIF_DEVICE_OS_DEVICE_INFO *osDevInfo;
- AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Read %d bytes\n", (A_UINT32)count));
+ AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Read %d bytes\n", (u32)count));
for (index=0; index < MAX_AR6000; index++) {
ar = (AR_SOFTC_T *)ar6k_priv(ar6000_devices[index]);
osDevInfo = &ar->osDevInfo;
AR_SOFTC_T *ar;
HIF_DEVICE_OS_DEVICE_INFO *osDevInfo;
- AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Write %d bytes\n", (A_UINT32)count));
+ AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Write %d bytes\n", (u32)count));
for (index=0; index < MAX_AR6000; index++) {
ar = (AR_SOFTC_T *)ar6k_priv(ar6000_devices[index]);
osDevInfo = &ar->osDevInfo;
#define AR6002_MAC_ADDRESS_OFFSET 0x0A
#define AR6003_MAC_ADDRESS_OFFSET 0x16
static
-void calculate_crc(A_UINT32 TargetType, A_UCHAR *eeprom_data)
+void calculate_crc(u32 TargetType, A_UCHAR *eeprom_data)
{
u16 *ptr_crc;
u16 *ptr16_eeprom;
u16 checksum;
- A_UINT32 i;
- A_UINT32 eeprom_size;
+ u32 i;
+ u32 eeprom_size;
if (TargetType == TARGET_TYPE_AR6001)
{
#endif /* SOFTMAC_FILE_USED */
static int
-ar6000_transfer_bin_file(AR_SOFTC_T *ar, AR6K_BIN_FILE file, A_UINT32 address, bool compressed)
+ar6000_transfer_bin_file(AR_SOFTC_T *ar, AR6K_BIN_FILE file, u32 address, bool compressed)
{
int status;
const char *filename;
const struct firmware *fw_entry;
- A_UINT32 fw_entry_size;
+ u32 fw_entry_size;
switch (file) {
case AR6K_OTP_FILE:
/* Load extended board data for AR6003 */
if ((file==AR6K_BOARD_DATA_FILE) && (fw_entry->data)) {
- A_UINT32 board_ext_address;
- A_UINT32 board_ext_data_size;
- A_UINT32 board_data_size;
+ u32 board_ext_address;
+ u32 board_ext_data_size;
+ u32 board_data_size;
board_ext_data_size = (((ar)->arTargetType == TARGET_TYPE_AR6002) ? AR6002_BOARD_EXT_DATA_SZ : \
(((ar)->arTargetType == TARGET_TYPE_AR6003) ? AR6003_BOARD_EXT_DATA_SZ : 0));
/* check whether the target has allocated memory for extended board data and file contains extended board data */
if ((board_ext_address) && (fw_entry->size == (board_data_size + board_ext_data_size))) {
- A_UINT32 param;
+ u32 param;
status = BMIWriteMemory(ar->arHifDevice, board_ext_address, (A_UCHAR *)(fw_entry->data + board_data_size), board_ext_data_size);
{
if (setupbtdev != 0) {
- A_UINT32 address;
+ u32 address;
if (BMIReadMemory(ar->arHifDevice,
HOST_INTEREST_ITEM_ADDRESS(ar, hi_board_data), (A_UCHAR *)&address, 4) != A_OK)
}
int
-ar6000_sysfs_bmi_get_config(AR_SOFTC_T *ar, A_UINT32 mode)
+ar6000_sysfs_bmi_get_config(AR_SOFTC_T *ar, u32 mode)
{
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Requesting device specific configuration\n"));
} else {
/* The config is contained within the driver itself */
int status;
- A_UINT32 param, options, sleep, address;
+ u32 param, options, sleep, address;
/* Temporarily disable system sleep */
address = MBOX_BASE_ADDRESS + LOCAL_SCRATCH_ADDRESS;
int
ar6000_configure_target(AR_SOFTC_T *ar)
{
- A_UINT32 param;
+ u32 param;
if (enableuartprint) {
param = 1;
if (BMIWriteMemory(ar->arHifDevice,
}
#endif
if (enabletimerwar) {
- A_UINT32 param;
+ u32 param;
if (BMIReadMemory(ar->arHifDevice,
HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
/* set the firmware mode to STA/IBSS/AP */
{
- A_UINT32 param;
+ u32 param;
if (BMIReadMemory(ar->arHifDevice,
HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
#ifdef ATH6KL_DISABLE_TARGET_DBGLOGS
{
- A_UINT32 param;
+ u32 param;
if (BMIReadMemory(ar->arHifDevice,
HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
}
void
-ar6000_ratemask_rx(void *devt, A_UINT32 ratemask)
+ar6000_ratemask_rx(void *devt, u32 ratemask)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
wake_up(&arEvent);
}
-u8 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, u32 *mapNo)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
u8 *datap;
ATH_MAC_HDR *macHdr;
- A_UINT32 i, eptMap;
+ u32 i, eptMap;
(*mapNo) = 0;
datap = A_NETBUF_DATA(skb);
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
u8 ac = AC_NOT_MAPPED;
HTC_ENDPOINT_ID eid = ENDPOINT_UNUSED;
- A_UINT32 mapNo = 0;
+ u32 mapNo = 0;
int len;
struct ar_cookie *cookie;
bool checkAdHocPsMapping = false,bMoreData = false;
void
applyAPTCHeuristics(AR_SOFTC_T *ar)
{
- A_UINT32 duration;
- A_UINT32 numbytes;
- A_UINT32 throughput;
+ u32 duration;
+ u32 numbytes;
+ u32 throughput;
struct timeval ts;
int status;
ar6000_tx_complete(void *Context, HTC_PACKET_QUEUE *pPacketQueue)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)Context;
- A_UINT32 mapNo = 0;
+ u32 mapNo = 0;
int status;
struct ar_cookie * ar_cookie;
HTC_ENDPOINT_ID eid;
ar->arNodeMap[mapNo].txPending --;
if (!ar->arNodeMap[mapNo].txPending && (mapNo == (ar->arNodeNum - 1))) {
- A_UINT32 i;
+ u32 i;
for (i = ar->arNodeNum; i > 0; i --) {
if (!ar->arNodeMap[i - 1].txPending) {
A_MEMZERO(&ar->arNodeMap[i - 1], sizeof(struct ar_node_mapping));
}
void
-ar6000_ready_event(void *devt, u8 *datap, u8 phyCap, A_UINT32 sw_ver, A_UINT32 abi_ver)
+ar6000_ready_event(void *devt, u8 *datap, u8 phyCap, u32 sw_ver, u32 abi_ver)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
struct net_device *dev = ar->arNetDev;
}
-void ar6000_set_numdataendpts(AR_SOFTC_T *ar, A_UINT32 num)
+void ar6000_set_numdataendpts(AR_SOFTC_T *ar, u32 num)
{
A_ASSERT(num <= (HTC_MAILBOX_NUM_MAX - 1));
ar->arNumDataEndPts = num;
}
void
-ar6000_regDomain_event(AR_SOFTC_T *ar, A_UINT32 regCode)
+ar6000_regDomain_event(AR_SOFTC_T *ar, u32 regCode)
{
A_PRINTF("AR6000 Reg Code = 0x%x\n", regCode);
ar->arRegCode = regCode;
}
void
-ar6000_targetStats_event(AR_SOFTC_T *ar, u8 *ptr, A_UINT32 len)
+ar6000_targetStats_event(AR_SOFTC_T *ar, u8 *ptr, u32 len)
{
u8 ac;
void
-ar6000_hbChallengeResp_event(AR_SOFTC_T *ar, A_UINT32 cookie, A_UINT32 source)
+ar6000_hbChallengeResp_event(AR_SOFTC_T *ar, u32 cookie, u32 source)
{
if (source == APP_HB_CHALLENGE) {
/* Report it to the app in case it wants a positive acknowledgement */
}
}
-A_UINT32 wmiSendCmdNum;
+u32 wmiSendCmdNum;
int
ar6000_control_tx(void *devt, void *osbuf, HTC_ENDPOINT_ID eid)
}
void
-ar6000_btcoex_config_event(struct ar6_softc *ar, u8 *ptr, A_UINT32 len)
+ar6000_btcoex_config_event(struct ar6_softc *ar, u8 *ptr, u32 len)
{
WMI_BTCOEX_CONFIG_EVENT *pBtcoexConfig = (WMI_BTCOEX_CONFIG_EVENT *)ptr;
}
void
-ar6000_btcoex_stats_event(struct ar6_softc *ar, u8 *ptr, A_UINT32 len)
+ar6000_btcoex_stats_event(struct ar6_softc *ar, u8 *ptr, u32 len)
{
WMI_BTCOEX_STATS_EVENT *pBtcoexStats = (WMI_BTCOEX_STATS_EVENT *)ptr;
static void
ar6000_cookie_init(AR_SOFTC_T *ar)
{
- A_UINT32 i;
+ u32 i;
ar->arCookieList = NULL;
ar->arCookieCount = 0;
-A_UINT32
-a_copy_to_user(void *to, const void *from, A_UINT32 n)
+u32 a_copy_to_user(void *to, const void *from, u32 n)
{
return(copy_to_user(to, from, n));
}
-A_UINT32
-a_copy_from_user(void *to, const void *from, A_UINT32 n)
+u32 a_copy_from_user(void *to, const void *from, u32 n)
{
return(copy_from_user(to, from, n));
}
switch(cfgParam)
{
case AR6000_DRIVER_CFG_GET_WLANNODECACHING:
- *((A_UINT32 *)result) = wlanNodeCaching;
+ *((u32 *)result) = wlanNodeCaching;
break;
case AR6000_DRIVER_CFG_LOG_RAW_WMI_MSGS:
- *((A_UINT32 *)result) = logWmiRawMsgs;
+ *((u32 *)result) = logWmiRawMsgs;
break;
default:
ret = EINVAL;
rssi_compensation_param.bg_param_b = *(u16 *)(cust_data_ptr+6) & 0xffff;
rssi_compensation_param.a_param_a = *(u16 *)(cust_data_ptr+8) & 0xffff;
rssi_compensation_param.a_param_b = *(u16 *)(cust_data_ptr+10) &0xffff;
- rssi_compensation_param.reserved = *(A_UINT32 *)(cust_data_ptr+12);
+ rssi_compensation_param.reserved = *(u32 *)(cust_data_ptr+12);
#ifdef RSSICOMPENSATION_PRINT
A_PRINTF("customerID = 0x%x \n", rssi_compensation_param.customerID);
}
A_INT32
-rssi_compensation_calc_tcmd(A_UINT32 freq, A_INT32 rssi, A_UINT32 totalPkt)
+rssi_compensation_calc_tcmd(u32 freq, A_INT32 rssi, u32 totalPkt)
{
if (freq > 5000)
void
ar6000_dset_open_req(
void *context,
- A_UINT32 id,
- A_UINT32 targHandle,
- A_UINT32 targReplyFn,
- A_UINT32 targReplyArg)
+ u32 id,
+ u32 targHandle,
+ u32 targReplyFn,
+ u32 targReplyArg)
{
}
void
ar6000_dset_close(
void *context,
- A_UINT32 access_cookie)
+ u32 access_cookie)
{
return;
}
void
ar6000_dset_data_req(
void *context,
- A_UINT32 accessCookie,
- A_UINT32 offset,
- A_UINT32 length,
- A_UINT32 targBuf,
- A_UINT32 targReplyFn,
- A_UINT32 targReplyArg)
+ u32 accessCookie,
+ u32 offset,
+ u32 length,
+ u32 targBuf,
+ u32 targReplyFn,
+ u32 targReplyArg)
{
}
ar->arWowState = WLAN_WOW_STATE_SUSPENDING;
if (ar->arTxPending[ar->arControlEp]) {
- A_UINT32 timeleft = wait_event_interruptible_timeout(arEvent,
+ u32 timeleft = wait_event_interruptible_timeout(arEvent,
ar->arTxPending[ar->arControlEp] == 0, wmitimeout * HZ);
if (!timeleft || signal_pending(current)) {
/* what can I do? wow resume at once */
}
}
-int ar6000_power_change_ev(void *context, A_UINT32 config)
+int ar6000_power_change_ev(void *context, u32 config)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)context;
int status = A_OK;
if (status == A_PENDING) {
#ifdef ANDROID_ENV
/* Wait for WMI ready event */
- A_UINT32 timeleft = wait_event_interruptible_timeout(arEvent,
+ u32 timeleft = wait_event_interruptible_timeout(arEvent,
(ar->arWmiReady == true), wmitimeout * HZ);
if (!timeleft || signal_pending(current)) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000 : Failed to get wmi ready \n"));
break;
}
if (ar->arTxPending[ar->arControlEp]) {
- A_UINT32 timeleft = wait_event_interruptible_timeout(arEvent,
+ u32 timeleft = wait_event_interruptible_timeout(arEvent,
ar->arTxPending[ar->arControlEp] == 0, wmitimeout * HZ);
if (!timeleft || signal_pending(current)) {
status = A_ERROR;
}
int
-ar6000_set_bt_hw_state(struct ar6_softc *ar, A_UINT32 enable)
+ar6000_set_bt_hw_state(struct ar6_softc *ar, u32 enable)
{
#ifdef CONFIG_PM
bool off = (enable == 0);
}
static int
-ar6k_set_cipher(AR_SOFTC_T *ar, A_UINT32 cipher, bool ucast)
+ar6k_set_cipher(AR_SOFTC_T *ar, u32 cipher, bool ucast)
{
u8 *ar_cipher = ucast ? &ar->arPairwiseCrypto :
&ar->arGroupCrypto;
}
static void
-ar6k_set_key_mgmt(AR_SOFTC_T *ar, A_UINT32 key_mgmt)
+ar6k_set_key_mgmt(AR_SOFTC_T *ar, u32 key_mgmt)
{
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s: 0x%x\n", __func__, key_mgmt));
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(ndev);
int ret = 0;
- A_UINT32 forceFgScan = 0;
+ u32 forceFgScan = 0;
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s: \n", __func__));
}
static int
-ar6k_cfg80211_set_wiphy_params(struct wiphy *wiphy, A_UINT32 changed)
+ar6k_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)wiphy_priv(wiphy);
static const
-A_UINT32 cipher_suites[] = {
+u32 cipher_suites[] = {
WLAN_CIPHER_SUITE_WEP40,
WLAN_CIPHER_SUITE_WEP104,
WLAN_CIPHER_SUITE_TKIP,
//
static A_UCHAR eeprom_data[EEPROM_SZ];
-static A_UINT32 sys_sleep_reg;
+static u32 sys_sleep_reg;
static HIF_DEVICE *p_bmi_device;
//
/* Read a Target register and return its value. */
inline void
-BMI_read_reg(A_UINT32 address, A_UINT32 *pvalue)
+BMI_read_reg(u32 address, u32 *pvalue)
{
BMIReadSOCRegister(p_bmi_device, address, pvalue);
}
/* Write a value to a Target register. */
inline void
-BMI_write_reg(A_UINT32 address, A_UINT32 value)
+BMI_write_reg(u32 address, u32 value)
{
BMIWriteSOCRegister(p_bmi_device, address, value);
}
/* Read Target memory word and return its value. */
inline void
-BMI_read_mem(A_UINT32 address, A_UINT32 *pvalue)
+BMI_read_mem(u32 address, u32 *pvalue)
{
BMIReadMemory(p_bmi_device, address, (A_UCHAR*)(pvalue), 4);
}
/* Write a word to a Target memory. */
inline void
-BMI_write_mem(A_UINT32 address, u8 *p_data, A_UINT32 sz)
+BMI_write_mem(u32 address, u8 *p_data, u32 sz)
{
BMIWriteMemory(p_bmi_device, address, (A_UCHAR*)(p_data), sz);
}
static void
enable_SI(HIF_DEVICE *p_device)
{
- A_UINT32 regval;
+ u32 regval;
printk("%s\n", __FUNCTION__);
static void
disable_SI(void)
{
- A_UINT32 regval;
+ u32 regval;
printk("%s\n", __FUNCTION__);
static void
request_8byte_read(int offset)
{
- A_UINT32 regval;
+ u32 regval;
// printk("%s: request_8byte_read from offset 0x%x\n", __FUNCTION__, offset);
* writing values from Target TX_DATA registers.
*/
static void
-request_4byte_write(int offset, A_UINT32 data)
+request_4byte_write(int offset, u32 data)
{
- A_UINT32 regval;
+ u32 regval;
printk("%s: request_4byte_write (0x%x) to offset 0x%x\n", __FUNCTION__, data, offset);
static bool
request_in_progress(void)
{
- A_UINT32 regval;
+ u32 regval;
/* Wait for DONE_INT in SI_CS */
BMI_read_reg(SI_BASE_ADDRESS+SI_CS_OFFSET, ®val);
static void eeprom_type_detect(void)
{
- A_UINT32 regval;
+ u32 regval;
u8 i = 0;
request_8byte_read(0x100);
* and return them to the caller.
*/
inline void
-read_8byte_results(A_UINT32 *data)
+read_8byte_results(u32 *data)
{
/* Read SI_RX_DATA0 and SI_RX_DATA1 */
BMI_read_reg(SI_BASE_ADDRESS+SI_RX_DATA0_OFFSET, &data[0]);
* waits for it to complete, and returns the result.
*/
static void
-fetch_8bytes(int offset, A_UINT32 *data)
+fetch_8bytes(int offset, u32 *data)
{
request_8byte_read(offset);
wait_for_eeprom_completion();
* and waits for it to complete.
*/
inline void
-commit_4bytes(int offset, A_UINT32 data)
+commit_4bytes(int offset, u32 data)
{
request_4byte_write(offset, data);
wait_for_eeprom_completion();
#ifdef ANDROID_ENV
void eeprom_ar6000_transfer(HIF_DEVICE *device, char *fake_file, char *p_mac)
{
- A_UINT32 first_word;
- A_UINT32 board_data_addr;
+ u32 first_word;
+ u32 board_data_addr;
int i;
printk("%s: Enter\n", __FUNCTION__);
* Fetch EEPROM_SZ Bytes of Board Data, 8 bytes at a time.
*/
- fetch_8bytes(0, (A_UINT32 *)(&eeprom_data[0]));
+ fetch_8bytes(0, (u32 *)(&eeprom_data[0]));
/* Check the first word of EEPROM for validity */
- first_word = *((A_UINT32 *)eeprom_data);
+ first_word = *((u32 *)eeprom_data);
if ((first_word == 0) || (first_word == 0xffffffff)) {
printk("Did not find EEPROM with valid Board Data.\n");
}
for (i=8; i<EEPROM_SZ; i+=8) {
- fetch_8bytes(i, (A_UINT32 *)(&eeprom_data[i]));
+ fetch_8bytes(i, (u32 *)(&eeprom_data[i]));
}
}
/* Record the fact that Board Data IS initialized */
{
- A_UINT32 one = 1;
+ u32 one = 1;
BMI_write_mem(HOST_INTEREST_ITEM_ADDRESS(hi_board_data_initialized),
- (u8 *)&one, sizeof(A_UINT32));
+ (u8 *)&one, sizeof(u32));
}
disable_SI();
int (*_HCI_TransportRecvHCIEventSync)(HCI_TRANSPORT_HANDLE HciTrans,
HTC_PACKET *pPacket,
int MaxPollMS);
-int (*_HCI_TransportSetBaudRate)(HCI_TRANSPORT_HANDLE HciTrans, A_UINT32 Baud);
+int (*_HCI_TransportSetBaudRate)(HCI_TRANSPORT_HANDLE HciTrans, u32 Baud);
int (*_HCI_TransportEnablePowerMgmt)(HCI_TRANSPORT_HANDLE HciTrans, bool Enable);
extern HCI_TRANSPORT_CALLBACKS ar6kHciTransCallbacks;
}
int ar6000_set_uart_config(HIF_DEVICE *hifDevice,
- A_UINT32 scale,
- A_UINT32 step)
+ u32 scale,
+ u32 step)
{
- A_UINT32 regAddress;
- A_UINT32 regVal;
+ u32 regAddress;
+ u32 regVal;
int status;
regAddress = WLAN_UART_BASE_ADDRESS | UART_CLKDIV_ADDRESS;
- regVal = ((A_UINT32)scale << 16) | step;
+ regVal = ((u32)scale << 16) | step;
/* change the HCI UART scale/step values through the diagnostic window */
status = ar6000_WriteRegDiag(hifDevice, ®Address, ®Val);
return status;
}
-int ar6000_get_core_clock_config(HIF_DEVICE *hifDevice, A_UINT32 *data)
+int ar6000_get_core_clock_config(HIF_DEVICE *hifDevice, u32 *data)
{
- A_UINT32 regAddress;
+ u32 regAddress;
int status;
regAddress = WLAN_RTC_BASE_ADDRESS | WLAN_CPU_CLOCK_ADDRESS;
{
AR6K_HCI_BRIDGE_INFO *pHcidevInfo = (AR6K_HCI_BRIDGE_INFO *)pContext;
int status;
- A_UINT32 address, hci_uart_pwr_mgmt_params;
+ u32 address, hci_uart_pwr_mgmt_params;
// AR3K_CONFIG_INFO ar3kconfig;
pHcidevInfo->pHCIDev = HCIHandle;
#define DBG_DEFAULTS (DBG_ERROR|DBG_WARNING)
-int ar6000_ReadRegDiag(HIF_DEVICE *hifDevice, A_UINT32 *address, A_UINT32 *data);
-int ar6000_WriteRegDiag(HIF_DEVICE *hifDevice, A_UINT32 *address, A_UINT32 *data);
+int ar6000_ReadRegDiag(HIF_DEVICE *hifDevice, u32 *address, u32 *data);
+int ar6000_WriteRegDiag(HIF_DEVICE *hifDevice, u32 *address, u32 *data);
#ifdef __cplusplus
extern "C" {
u8 key_len;
u8 seq[IW_ENCODE_SEQ_MAX_SIZE];
u8 seq_len;
- A_UINT32 cipher;
+ u32 cipher;
};
#endif /* ATH6K_CONFIG_CFG80211 */
struct ar_hb_chlng_resp {
A_TIMER timer;
- A_UINT32 frequency;
- A_UINT32 seqNum;
+ u32 frequency;
+ u32 seqNum;
bool outstanding;
u8 missCnt;
u8 missThres;
u16 arListenIntervalB;
u16 arListenIntervalT;
struct ar6000_version arVersion;
- A_UINT32 arTargetType;
+ u32 arTargetType;
A_INT8 arRssi;
u8 arTxPwr;
bool arTxPwrSet;
struct iw_statistics arIwStats;
A_INT8 arNumChannels;
u16 arChannelList[32];
- A_UINT32 arRegCode;
+ u32 arRegCode;
bool statsUpdatePending;
TARGET_STATS arTargetStats;
A_INT8 arMaxRetries;
u8 arPhyCapability;
#ifdef CONFIG_HOST_TCMD_SUPPORT
u8 tcmdRxReport;
- A_UINT32 tcmdRxTotalPkt;
+ u32 tcmdRxTotalPkt;
A_INT32 tcmdRxRssi;
- A_UINT32 tcmdPm;
- A_UINT32 arTargetMode;
- A_UINT32 tcmdRxcrcErrPkt;
- A_UINT32 tcmdRxsecErrPkt;
+ u32 tcmdPm;
+ u32 arTargetMode;
+ u32 tcmdRxcrcErrPkt;
+ u32 tcmdRxsecErrPkt;
u16 tcmdRateCnt[TCMD_MAX_RATES];
u16 tcmdRateCntShortGuard[TCMD_MAX_RATES];
#endif
u8 arNodeNum;
u8 arNexEpId;
struct ar_cookie *arCookieList;
- A_UINT32 arCookieCount;
- A_UINT32 arRateMask;
+ u32 arCookieCount;
+ u32 arRateMask;
u8 arSkipScan;
u16 arBeaconInterval;
bool arConnectPending;
bool arWmmEnabled;
struct ar_hb_chlng_resp arHBChallengeResp;
u8 arKeepaliveConfigured;
- A_UINT32 arMgmtFilter;
+ u32 arMgmtFilter;
HTC_ENDPOINT_ID arAc2EpMapping[WMM_NUM_AC];
bool arAcStreamActive[WMM_NUM_AC];
u8 arAcStreamPriMap[WMM_NUM_AC];
bool arWMIControlEpFull;
bool dbgLogFetchInProgress;
A_UCHAR log_buffer[DBGLOG_HOST_LOG_BUFFER_SIZE];
- A_UINT32 log_cnt;
- A_UINT32 dbglog_init_done;
- A_UINT32 arConnectCtrlFlags;
+ u32 log_cnt;
+ u32 dbglog_init_done;
+ u32 arConnectCtrlFlags;
#ifdef USER_KEYS
A_INT32 user_savedkeys_stat;
- A_UINT32 user_key_ctrl;
+ u32 user_key_ctrl;
struct USER_SAVEDKEYS user_saved_keys;
#endif
USER_RSSI_THOLD rssi_map[12];
struct ar_giwscan_param {
char *current_ev;
char *end_buf;
- A_UINT32 bytes_needed;
+ u32 bytes_needed;
struct iw_request_info *info;
};
struct ar6_softc;
void ar6000_ready_event(void *devt, u8 *datap, u8 phyCap,
- A_UINT32 sw_ver, A_UINT32 abi_ver);
+ u32 sw_ver, u32 abi_ver);
int ar6000_control_tx(void *devt, void *osbuf, HTC_ENDPOINT_ID eid);
void ar6000_connect_event(struct ar6_softc *ar, u16 channel,
u8 *bssid, u16 listenInterval,
bool ismcast);
void ar6000_bitrate_rx(void *devt, A_INT32 rateKbps);
void ar6000_channelList_rx(void *devt, A_INT8 numChan, u16 *chanList);
-void ar6000_regDomain_event(struct ar6_softc *ar, A_UINT32 regCode);
+void ar6000_regDomain_event(struct ar6_softc *ar, u32 regCode);
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_set_numdataendpts(struct ar6_softc *ar, u32 num);
void ar6000_scanComplete_event(struct ar6_softc *ar, int status);
-void ar6000_targetStats_event(struct ar6_softc *ar, u8 *ptr, A_UINT32 len);
+void ar6000_targetStats_event(struct ar6_softc *ar, u8 *ptr, u32 len);
void ar6000_rssiThreshold_event(struct ar6_softc *ar,
WMI_RSSI_THRESHOLD_VAL newThreshold,
A_INT16 rssi);
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, u16 oldChannel, u16 newChannel);
-void ar6000_hbChallengeResp_event(struct ar6_softc *, A_UINT32 cookie, A_UINT32 source);
+void ar6000_hbChallengeResp_event(struct ar6_softc *, u32 cookie, u32 source);
void
ar6000_roam_tbl_event(struct ar6_softc *ar, WMI_TARGET_ROAM_TBL *pTbl);
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_gpio_intr_rx(u32 intr_mask, u32 input_values);
+void ar6000_gpio_data_rx(u32 reg_id, u32 value);
void ar6000_gpio_ack_rx(void);
-A_INT32 rssi_compensation_calc_tcmd(A_UINT32 freq, A_INT32 rssi, A_UINT32 totalPkt);
+A_INT32 rssi_compensation_calc_tcmd(u32 freq, A_INT32 rssi, u32 totalPkt);
A_INT16 rssi_compensation_calc(struct ar6_softc *ar, A_INT16 rssi);
A_INT16 rssi_compensation_reverse_calc(struct ar6_softc *ar, A_INT16 rssi, bool Above);
void ar6000_lqThresholdEvent_rx(void *devt, WMI_LQ_THRESHOLD_VAL range, u8 lqVal);
-void ar6000_ratemask_rx(void *devt, A_UINT32 ratemask);
+void ar6000_ratemask_rx(void *devt, u32 ratemask);
int ar6000_get_driver_cfg(struct net_device *dev,
u16 cfgParam,
void *result);
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);
+void ar6000_dbglog_event(struct ar6_softc *ar, u32 dropped,
+ A_INT8 *buffer, u32 length);
int ar6000_dbglog_get_debug_logs(struct ar6_softc *ar);
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, u8 *ptr, A_UINT32 len);
+void ar6000_btcoex_config_event(struct ar6_softc *ar, u8 *ptr, u32 len);
-void ar6000_btcoex_stats_event(struct ar6_softc *ar, u8 *ptr, A_UINT32 len) ;
+void ar6000_btcoex_stats_event(struct ar6_softc *ar, u8 *ptr, u32 len) ;
void ar6000_dset_open_req(void *devt,
- A_UINT32 id,
- A_UINT32 targ_handle,
- A_UINT32 targ_reply_fn,
- A_UINT32 targ_reply_arg);
-void ar6000_dset_close(void *devt, A_UINT32 access_cookie);
+ u32 id,
+ u32 targ_handle,
+ u32 targ_reply_fn,
+ u32 targ_reply_arg);
+void ar6000_dset_close(void *devt, u32 access_cookie);
void ar6000_dset_data_req(void *devt,
- A_UINT32 access_cookie,
- A_UINT32 offset,
- A_UINT32 length,
- A_UINT32 targ_buf,
- A_UINT32 targ_reply_fn,
- A_UINT32 targ_reply_arg);
+ u32 access_cookie,
+ u32 offset,
+ u32 length,
+ u32 targ_buf,
+ u32 targ_reply_fn,
+ u32 targ_reply_arg);
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
void prof_count_rx(unsigned int addr, unsigned int count);
#endif
-A_UINT32 ar6000_getnodeAge (void);
+u32 ar6000_getnodeAge (void);
-A_UINT32 ar6000_getclkfreq (void);
+u32 ar6000_getclkfreq (void);
int ar6000_ap_mode_profile_commit(struct ar6_softc *ar);
int ar6000_connect_to_ap(struct ar6_softc *ar);
int ar6000_update_wlan_pwr_state(struct ar6_softc *ar, AR6000_WLAN_STATE state, bool suspending);
int ar6000_set_wlan_state(struct ar6_softc *ar, AR6000_WLAN_STATE state);
-int ar6000_set_bt_hw_state(struct ar6_softc *ar, A_UINT32 state);
+int ar6000_set_bt_hw_state(struct ar6_softc *ar, u32 state);
#ifdef CONFIG_PM
int ar6000_suspend_ev(void *context);
int ar6000_resume_ev(void *context);
-int ar6000_power_change_ev(void *context, A_UINT32 config);
+int ar6000_power_change_ev(void *context, u32 config);
void ar6000_check_wow_status(struct ar6_softc *ar, struct sk_buff *skb, bool isEvent);
#endif
* UINT32 number of bytes
* UINT32 activate? (0 or 1)
* }
- * A_UINT32 resulting rompatch ID
+ * u32 resulting rompatch ID
* }
* uses: BMI_ROMPATCH_INSTALL
*/
#define AR6000_XIOCTL_WMI_SET_MGMT_FRM_RX_FILTER 66
/*
* arguments:
- * A_UINT32 filter_type;
+ * u32 filter_type;
*/
#define AR6000_XIOCTL_DBGLOG_CFG_MODULE 67
#define AR6000_XIOCTL_WMI_SET_WSC_STATUS 70
/*
* arguments:
- * A_UINT32 wsc_status;
+ * u32 wsc_status;
* (WSC_REG_INACTIVE or WSC_REG_ACTIVE)
*/
/*
* arguments:
* UINT32 cmd (AR6000_XIOCTL_TARGET_INFO)
- * A_UINT32 TargetVersion (returned)
- * A_UINT32 TargetType (returned)
+ * u32 TargetVersion (returned)
+ * u32 TargetType (returned)
* (See also bmi_msg.h target_ver and target_type)
*/
* This ioctl is used to set the connect control flags
*
* arguments:
- * A_UINT32 connectCtrlFlags
+ * u32 connectCtrlFlags
*/
#define AR6000_XIOCTL_WMI_SET_AKMP_PARAMS 82
*
* arguments:
* struct {
- * A_UINT32 akmpInfo;
+ * u32 akmpInfo;
* }
* uses: WMI_SET_AKMP_PARAMS_CMD
*/
*
* arguments:
* struct {
- * A_UINT32 numPMKID;
+ * u32 numPMKID;
* WMI_PMKID pmkidList[WMI_MAX_PMKID_CACHE];
* }
* uses: WMI_SET_PMKIDLIST_CMD
#define AR6000_XIOCTL_PROF_CFG 93
/*
* arguments:
- * A_UINT32 period
- * A_UINT32 nbins
+ * u32 period
+ * u32 nbins
*/
#define AR6000_XIOCTL_PROF_ADDR_SET 94
/*
* arguments:
- * A_UINT32 Target address
+ * u32 Target address
*/
#define AR6000_XIOCTL_PROF_START 95
/* used by AR6000_IOCTL_WMI_GETREV */
struct ar6000_version {
- A_UINT32 host_ver;
- A_UINT32 target_ver;
- A_UINT32 wlan_ver;
- A_UINT32 abi_ver;
+ u32 host_ver;
+ u32 target_ver;
+ u32 wlan_ver;
+ u32 abi_ver;
};
/* used by AR6000_IOCTL_WMI_GET_QOS_QUEUE */
A_INT32 tx_unicast_rate;
A_INT32 rx_unicast_rate;
- A_UINT32 lq_val;
+ u32 lq_val;
- A_UINT32 wow_num_pkts_dropped;
+ u32 wow_num_pkts_dropped;
u16 wow_num_events_discarded;
A_INT16 noise_floor_calibation;
u8 wow_num_host_pkt_wakeups;
u8 wow_num_host_event_wakeups;
- A_UINT32 arp_received;
- A_UINT32 arp_matched;
- A_UINT32 arp_replied;
+ u32 arp_received;
+ u32 arp_matched;
+ u32 arp_replied;
}TARGET_STATS;
typedef struct targetStats_cmd_t {
#define AR6000_USER_SETKEYS_RSC_UNCHANGED 0x00000002
typedef struct {
- A_UINT32 keyOpCtrl; /* Bit Map of Key Mgmt Ctrl Flags */
+ u32 keyOpCtrl; /* Bit Map of Key Mgmt Ctrl Flags */
} AR6000_USER_SETKEYS_INFO;
/* used by AR6000_XIOCTL_GPIO_OUTPUT_SET */
struct ar6000_gpio_output_set_cmd_s {
- A_UINT32 set_mask;
- A_UINT32 clear_mask;
- A_UINT32 enable_mask;
- A_UINT32 disable_mask;
+ u32 set_mask;
+ u32 clear_mask;
+ u32 enable_mask;
+ u32 disable_mask;
};
/*
* used by AR6000_XIOCTL_GPIO_REGISTER_GET and AR6000_XIOCTL_GPIO_REGISTER_SET
*/
struct ar6000_gpio_register_cmd_s {
- A_UINT32 gpioreg_id;
- A_UINT32 value;
+ u32 gpioreg_id;
+ u32 value;
};
/* used by AR6000_XIOCTL_GPIO_INTR_ACK */
struct ar6000_gpio_intr_ack_cmd_s {
- A_UINT32 ack_mask;
+ u32 ack_mask;
};
/* used by AR6000_XIOCTL_GPIO_INTR_WAIT */
struct ar6000_gpio_intr_wait_cmd_s {
- A_UINT32 intr_mask;
- A_UINT32 input_values;
+ u32 intr_mask;
+ u32 input_values;
};
/* used by the AR6000_XIOCTL_DBGLOG_CFG_MODULE */
typedef struct ar6000_dbglog_module_config_s {
- A_UINT32 valid;
+ u32 valid;
u16 mmask;
u16 tsr;
u32 rep;
typedef struct user_rssi_params_t {
u8 weight;
- A_UINT32 pollTime;
+ u32 pollTime;
USER_RSSI_THOLD tholds[12];
} USER_RSSI_PARAMS;
typedef struct ar6000_get_btcoex_config_cmd_t{
- A_UINT32 btProfileType;
- A_UINT32 linkId;
+ u32 btProfileType;
+ u32 linkId;
}AR6000_GET_BTCOEX_CONFIG_CMD;
typedef struct ar6000_btcoex_config_t {
AR6000_GET_BTCOEX_CONFIG_CMD configCmd;
- A_UINT32 * configEvent;
+ u32 *configEvent;
} AR6000_BTCOEX_CONFIG;
typedef struct ar6000_btcoex_stats_t {
- A_UINT32 * statsEvent;
+ u32 *statsEvent;
}AR6000_BTCOEX_STATS;
/*
* Host driver may have some config parameters. Typically, these
struct ar6000_traffic_activity_change {
- A_UINT32 StreamID; /* stream ID to indicate activity change */
- A_UINT32 Active; /* active (1) or inactive (0) */
+ u32 StreamID; /* stream ID to indicate activity change */
+ u32 Active; /* active (1) or inactive (0) */
};
/* Used with AR6000_XIOCTL_PROF_COUNT_GET */
struct prof_count_s {
- A_UINT32 addr; /* bin start address */
- A_UINT32 count; /* hit count */
+ u32 addr; /* bin start address */
+ u32 count; /* hit count */
};
/* AR6000_XIOCTL_DUMP_MODULE_DEBUG_INFO */
struct drv_debug_module_s {
char modulename[128]; /* name of module */
- A_UINT32 mask; /* new mask to set .. or .. current mask */
+ u32 mask; /* new mask to set .. or .. current mask */
};
extern int (*_HCI_TransportRecvHCIEventSync)(HCI_TRANSPORT_HANDLE HciTrans,
HTC_PACKET *pPacket,
int MaxPollMS);
-extern int (*_HCI_TransportSetBaudRate)(HCI_TRANSPORT_HANDLE HciTrans, A_UINT32 Baud);
+extern int (*_HCI_TransportSetBaudRate)(HCI_TRANSPORT_HANDLE HciTrans, u32 Baud);
extern int (*_HCI_TransportEnablePowerMgmt)(HCI_TRANSPORT_HANDLE HciTrans, bool Enable);
extern int ar6000_get_hif_dev(HIF_DEVICE *device, void *config);
-extern int ar6000_set_uart_config(HIF_DEVICE *hifDevice, A_UINT32 scale, A_UINT32 step);
+extern int ar6000_set_uart_config(HIF_DEVICE *hifDevice, u32 scale, u32 step);
/* get core clock register settings
* data: 0 - 40/44MHz
* where (5G band/2.4G band)
* assume 2.4G band for now
*/
-extern int ar6000_get_core_clock_config(HIF_DEVICE *hifDevice, A_UINT32 *data);
+extern int ar6000_get_core_clock_config(HIF_DEVICE *hifDevice, u32 *data);
void *a_netbuf_alloc_raw(int size);
void a_netbuf_free(void *bufPtr);
void *a_netbuf_to_data(void *bufPtr);
-A_UINT32 a_netbuf_to_len(void *bufPtr);
+u32 a_netbuf_to_len(void *bufPtr);
int a_netbuf_push(void *bufPtr, A_INT32 len);
int a_netbuf_push_data(void *bufPtr, char *srcPtr, A_INT32 len);
int a_netbuf_put(void *bufPtr, A_INT32 len);
/*
* Kernel v.s User space functions
*/
-A_UINT32 a_copy_to_user(void *to, const void *from, A_UINT32 n);
-A_UINT32 a_copy_from_user(void *to, const void *from, A_UINT32 n);
+u32 a_copy_to_user(void *to, const void *from, u32 n);
+u32 a_copy_from_user(void *to, const void *from, u32 n);
/* In linux, WLAN Rx and Tx run in different contexts, so no need to check
* for any commands/data queued for WLAN */
#include "wlan_config.h"
extern int enablerssicompensation;
-A_UINT32 tcmdRxFreq;
+u32 tcmdRxFreq;
extern unsigned int wmitimeout;
extern A_WAITQUEUE_HEAD arEvent;
extern int tspecCompliance;
#ifdef CONFIG_HOST_TCMD_SUPPORT
static int
ar6000_ioctl_tcmd_get_rx_report(struct net_device *dev,
- struct ifreq *rq, u8 *data, A_UINT32 len)
+ struct ifreq *rq, u8 *data, u32 len)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
- A_UINT32 buf[4+TCMD_MAX_RATES];
+ u32 buf[4+TCMD_MAX_RATES];
int ret = 0;
if (ar->bIsDestroyProgress) {
buf[1] = ar->tcmdRxRssi;
buf[2] = ar->tcmdRxcrcErrPkt;
buf[3] = ar->tcmdRxsecErrPkt;
- A_MEMCPY(((A_UCHAR *)buf)+(4*sizeof(A_UINT32)), ar->tcmdRateCnt, sizeof(ar->tcmdRateCnt));
- A_MEMCPY(((A_UCHAR *)buf)+(4*sizeof(A_UINT32))+(TCMD_MAX_RATES *sizeof(u16)), ar->tcmdRateCntShortGuard, sizeof(ar->tcmdRateCntShortGuard));
+ A_MEMCPY(((A_UCHAR *)buf)+(4*sizeof(u32)), ar->tcmdRateCnt, sizeof(ar->tcmdRateCnt));
+ A_MEMCPY(((A_UCHAR *)buf)+(4*sizeof(u32))+(TCMD_MAX_RATES *sizeof(u16)), ar->tcmdRateCntShortGuard, sizeof(ar->tcmdRateCntShortGuard));
if (!ret && copy_to_user(rq->ifr_data, buf, sizeof(buf))) {
ret = -EFAULT;
ar6000_ioctl_get_ap_stats(struct net_device *dev, struct ifreq *rq)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
- A_UINT32 action; /* Allocating only the desired space on the frame. Declaring is as a WMI_AP_MODE_STAT variable results in exceeding the compiler imposed limit on the maximum frame size */
+ u32 action; /* Allocating only the desired space on the frame. Declaring is as a WMI_AP_MODE_STAT variable results in exceeding the compiler imposed limit on the maximum frame size */
WMI_AP_MODE_STAT *pStats = &ar->arAPStats;
int ret = 0;
return -EIO;
}
if (copy_from_user(&action, (char *)((unsigned int*)rq->ifr_data + 1),
- sizeof(A_UINT32)))
+ sizeof(u32)))
{
return -EFAULT;
}
* input_values shows a recent value of GPIO pins.
*/
void
-ar6000_gpio_intr_rx(A_UINT32 intr_mask, A_UINT32 input_values)
+ar6000_gpio_intr_rx(u32 intr_mask, u32 input_values)
{
gpio_intr_results.intr_mask = intr_mask;
gpio_intr_results.input_values = input_values;
* call.
*/
void
-ar6000_gpio_data_rx(A_UINT32 reg_id, A_UINT32 value)
+ar6000_gpio_data_rx(u32 reg_id, u32 value)
{
gpio_reg_results.gpioreg_id = reg_id;
gpio_reg_results.value = value;
int
ar6000_gpio_output_set(struct net_device *dev,
- A_UINT32 set_mask,
- A_UINT32 clear_mask,
- A_UINT32 enable_mask,
- A_UINT32 disable_mask)
+ u32 set_mask,
+ u32 clear_mask,
+ u32 enable_mask,
+ u32 disable_mask)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
static int
ar6000_gpio_register_set(struct net_device *dev,
- A_UINT32 gpioreg_id,
- A_UINT32 value)
+ u32 gpioreg_id,
+ u32 value)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
static int
ar6000_gpio_register_get(struct net_device *dev,
- A_UINT32 gpioreg_id)
+ u32 gpioreg_id)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
static int
ar6000_gpio_intr_ack(struct net_device *dev,
- A_UINT32 ack_mask)
+ u32 ack_mask)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
* for a previous prof_count_get call.
*/
void
-prof_count_rx(A_UINT32 addr, A_UINT32 count)
+prof_count_rx(u32 addr, u32 count)
{
prof_count_results.addr = addr;
prof_count_results.count = count;
unsigned int length = 0;
unsigned char *buffer;
char *userdata;
- A_UINT32 connectCtrlFlags;
+ u32 connectCtrlFlags;
WMI_SET_AKMP_PARAMS_CMD akmpParams;
}
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Execute (address: 0x%x, param: %d)\n",
address, param));
- ret = BMIExecute(hifDevice, address, (A_UINT32*)¶m);
+ ret = BMIExecute(hifDevice, address, (u32 *)¶m);
/* return value */
if (put_user(param, (unsigned int *)rq->ifr_data)) {
ret = -EFAULT;
ret = -EFAULT;
break;
}
- ret = BMIReadSOCRegister(hifDevice, address, (A_UINT32*)¶m);
+ ret = BMIReadSOCRegister(hifDevice, address, (u32 *)¶m);
/* return value */
if (put_user(param, (unsigned int *)rq->ifr_data)) {
ret = -EFAULT;
/* Configure Target-side profiling */
case AR6000_XIOCTL_PROF_CFG:
{
- A_UINT32 period;
- A_UINT32 nbins;
+ u32 period;
+ u32 nbins;
if (get_user(period, (unsigned int *)userdata) ||
get_user(nbins, (unsigned int *)userdata + 1)) {
ret = -EFAULT;
/* Start a profiling bucket/bin at the specified address */
case AR6000_XIOCTL_PROF_ADDR_SET:
{
- A_UINT32 addr;
+ u32 addr;
if (get_user(addr, (unsigned int *)userdata)) {
ret = -EFAULT;
break;
/* If we made it to here, then the Target exists and is ready. */
if (cmd == AR6000_XIOCTL_TARGET_INFO) {
- if (copy_to_user((A_UINT32 *)rq->ifr_data, &ar->arVersion.target_ver,
+ if (copy_to_user((u32 *)rq->ifr_data, &ar->arVersion.target_ver,
sizeof(ar->arVersion.target_ver)))
{
ret = -EFAULT;
}
- if (copy_to_user(((A_UINT32 *)rq->ifr_data)+1, &ar->arTargetType,
+ if (copy_to_user(((u32 *)rq->ifr_data)+1, &ar->arTargetType,
sizeof(ar->arTargetType)))
{
ret = -EFAULT;
}
case AR6000_XIOCTL_WMI_GET_HB_CHALLENGE_RESP:
{
- A_UINT32 cookie;
+ u32 cookie;
if (copy_from_user(&cookie, userdata, sizeof(cookie))) {
ret = -EFAULT;
}
case AR6000_XIOCTL_DIAG_READ:
{
- A_UINT32 addr, data;
+ u32 addr, data;
if (get_user(addr, (unsigned int *)userdata)) {
ret = -EFAULT;
break;
}
case AR6000_XIOCTL_DIAG_WRITE:
{
- A_UINT32 addr, data;
+ u32 addr, data;
if (get_user(addr, (unsigned int *)userdata) ||
get_user(data, (unsigned int *)userdata + 1)) {
ret = -EFAULT;
{
WMI_SET_APPIE_CMD appIEcmd;
u8 appIeInfo[IEEE80211_APPIE_FRAME_MAX_LEN];
- A_UINT32 fType,ieLen;
+ u32 fType,ieLen;
if (ar->arWmiReady == false) {
ret = -EIO;
goto ioctl_done;
}
- if (get_user(fType, (A_UINT32 *)userdata)) {
+ if (get_user(fType, (u32 *)userdata)) {
ret = -EFAULT;
break;
}
if (appIEcmd.mgmtFrmType >= IEEE80211_APPIE_NUM_OF_FRAME) {
ret = -EIO;
} else {
- if (get_user(ieLen, (A_UINT32 *)(userdata + 4))) {
+ if (get_user(ieLen, (u32 *)(userdata + 4))) {
ret = -EFAULT;
break;
}
case AR6000_XIOCTL_WMI_SET_MGMT_FRM_RX_FILTER:
{
WMI_BSS_FILTER_CMD cmd;
- A_UINT32 filterType;
+ u32 filterType;
- if (copy_from_user(&filterType, userdata, sizeof(A_UINT32)))
+ if (copy_from_user(&filterType, userdata, sizeof(u32)))
{
ret = -EFAULT;
goto ioctl_done;
}
case AR6000_XIOCTL_WMI_SET_WSC_STATUS:
{
- A_UINT32 wsc_status;
+ u32 wsc_status;
if (ar->arWmiReady == false) {
ret = -EIO;
goto ioctl_done;
- } else if (copy_from_user(&wsc_status, userdata, sizeof(A_UINT32)))
+ } else if (copy_from_user(&wsc_status, userdata, sizeof(u32)))
{
ret = -EFAULT;
goto ioctl_done;
}
case AR6000_XIOCTL_BMI_ROMPATCH_INSTALL:
{
- A_UINT32 ROM_addr;
- A_UINT32 RAM_addr;
- A_UINT32 nbytes;
- A_UINT32 do_activate;
- A_UINT32 rompatch_id;
-
- if (get_user(ROM_addr, (A_UINT32 *)userdata) ||
- get_user(RAM_addr, (A_UINT32 *)userdata + 1) ||
- get_user(nbytes, (A_UINT32 *)userdata + 2) ||
- get_user(do_activate, (A_UINT32 *)userdata + 3)) {
+ u32 ROM_addr;
+ u32 RAM_addr;
+ u32 nbytes;
+ u32 do_activate;
+ u32 rompatch_id;
+
+ if (get_user(ROM_addr, (u32 *)userdata) ||
+ get_user(RAM_addr, (u32 *)userdata + 1) ||
+ get_user(nbytes, (u32 *)userdata + 2) ||
+ get_user(do_activate, (u32 *)userdata + 3)) {
ret = -EFAULT;
break;
}
case AR6000_XIOCTL_BMI_ROMPATCH_UNINSTALL:
{
- A_UINT32 rompatch_id;
+ u32 rompatch_id;
- if (get_user(rompatch_id, (A_UINT32 *)userdata)) {
+ if (get_user(rompatch_id, (u32 *)userdata)) {
ret = -EFAULT;
break;
}
case AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE:
case AR6000_XIOCTL_BMI_ROMPATCH_DEACTIVATE:
{
- A_UINT32 rompatch_count;
+ u32 rompatch_count;
- if (get_user(rompatch_count, (A_UINT32 *)userdata)) {
+ if (get_user(rompatch_count, (u32 *)userdata)) {
ret = -EFAULT;
break;
}
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Change rompatch activation count=%d\n", rompatch_count));
- length = sizeof(A_UINT32) * rompatch_count;
+ length = sizeof(u32) * rompatch_count;
if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
A_MEMZERO(buffer, length);
if (copy_from_user(buffer, &userdata[sizeof(rompatch_count)], length))
ret = -EFAULT;
} else {
if (cmd == AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE) {
- ret = BMIrompatchActivate(hifDevice, rompatch_count, (A_UINT32 *)buffer);
+ ret = BMIrompatchActivate(hifDevice, rompatch_count, (u32 *)buffer);
} else {
- ret = BMIrompatchDeactivate(hifDevice, rompatch_count, (A_UINT32 *)buffer);
+ ret = BMIrompatchDeactivate(hifDevice, rompatch_count, (u32 *)buffer);
}
}
A_FREE(buffer);
}
case AR6000_XIOCTL_AP_CONN_INACT_TIME:
{
- A_UINT32 period;
+ u32 period;
if (ar->arWmiReady == false) {
ret = -EIO;
} else if (copy_from_user(&period, userdata, sizeof(period))) {
}
case AR6000_XIOCTL_FETCH_TARGET_REGS:
{
- A_UINT32 targregs[AR6003_FETCH_TARG_REGS_COUNT];
+ u32 targregs[AR6003_FETCH_TARG_REGS_COUNT];
if (ar->arTargetType == TARGET_TYPE_AR6003) {
ar6k_FetchTargetRegs(hifDevice, targregs);
- if (copy_to_user((A_UINT32 *)rq->ifr_data, &targregs, sizeof(targregs)))
+ if (copy_to_user((u32 *)rq->ifr_data, &targregs, sizeof(targregs)))
{
ret = -EFAULT;
}
dev_kfree_skb(skb);
}
-A_UINT32
-a_netbuf_to_len(void *bufPtr)
+u32 a_netbuf_to_len(void *bufPtr)
{
return (((struct sk_buff *)bufPtr)->len);
}
struct ieee80211_common_ie *cie;
char *current_val;
A_INT32 j;
- A_UINT32 rate_len, data_len = 0;
+ u32 rate_len, data_len = 0;
param = (struct ar_giwscan_param *)arg;
struct iw_param *rrq, char *extra)
{
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
- A_UINT32 kbps;
+ u32 kbps;
A_INT8 rate_idx;
if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
A_INT32 keyLen;
u8 *keyData;
A_INT32 index;
- A_UINT32 *PN;
+ u32 *PN;
A_INT32 i;
int status;
u8 wapiKeyRsc[16];
if (A_MEMCMP(ext->addr.sa_data, broadcastMac, sizeof(broadcastMac)) == 0) {
keyUsage |= GROUP_USAGE;
- PN = (A_UINT32 *)wapiKeyRsc;
+ PN = (u32 *)wapiKeyRsc;
for (i = 0; i < 4; i++) {
PN[i] = PN_INIT;
}
bool timerMon; /* true if the timer started for the sake of this TID */
u16 win_sz; /* negotiated window size */
u16 seq_next; /* Next seq no, in current window */
- A_UINT32 hold_q_sz; /* Num of frames that can be held in hold q */
+ u32 hold_q_sz; /* Num of frames that can be held in hold q */
OSBUF_HOLD_Q *hold_q; /* Hold q for re-order */
#if 0
WINDOW_SNAPSHOT old_win; /* Sliding window snapshot - for timeout */
}RXTID;
typedef struct {
- A_UINT32 num_into_aggr; /* hitting at the input of this module */
- A_UINT32 num_dups; /* duplicate */
- A_UINT32 num_oow; /* out of window */
- A_UINT32 num_mpdu; /* single payload 802.3/802.11 frame */
- A_UINT32 num_amsdu; /* AMSDU */
- A_UINT32 num_delivered; /* frames delivered to IP stack */
- A_UINT32 num_timeouts; /* num of timeouts, during which frames delivered */
- A_UINT32 num_hole; /* frame not present, when window moved over */
- A_UINT32 num_bar; /* num of resets of seq_num, via BAR */
+ u32 num_into_aggr; /* hitting at the input of this module */
+ u32 num_dups; /* duplicate */
+ u32 num_oow; /* out of window */
+ u32 num_mpdu; /* single payload 802.3/802.11 frame */
+ u32 num_amsdu; /* AMSDU */
+ u32 num_delivered; /* frames delivered to IP stack */
+ u32 num_timeouts; /* num of timeouts, during which frames delivered */
+ u32 num_hole; /* frame not present, when window moved over */
+ u32 num_bar; /* num of resets of seq_num, via BAR */
}RXTID_STATS;
typedef struct {
u8 tsInfo_reserved;
u16 nominalMSDU;
u16 maxMSDU;
- A_UINT32 minServiceInt;
- A_UINT32 maxServiceInt;
- A_UINT32 inactivityInt;
- A_UINT32 suspensionInt;
- A_UINT32 serviceStartTime;
- A_UINT32 minDataRate;
- A_UINT32 meanDataRate;
- A_UINT32 peakDataRate;
- A_UINT32 maxBurstSize;
- A_UINT32 delayBound;
- A_UINT32 minPhyRate;
+ u32 minServiceInt;
+ u32 maxServiceInt;
+ u32 inactivityInt;
+ u32 suspensionInt;
+ u32 serviceStartTime;
+ u32 minDataRate;
+ u32 meanDataRate;
+ u32 peakDataRate;
+ u32 maxBurstSize;
+ u32 delayBound;
+ u32 minPhyRate;
u16 sba;
u16 mediumTime;
} POSTPACK WMM_TSPEC_IE;
struct bss *nt_node_last; /* information of all nodes */
struct bss *nt_hash[IEEE80211_NODE_HASHSIZE];
const char *nt_name; /* for debugging */
- A_UINT32 nt_scangen; /* gen# for timeout scan */
+ u32 nt_scangen; /* gen# for timeout scan */
#ifdef THREAD_X
A_TIMER nt_inact_timer;
u8 isTimerArmed; /* is the node timer armed */
#endif
- A_UINT32 nt_nodeAge; /* node aging time */
+ u32 nt_nodeAge; /* node aging time */
#ifdef OS_ROAM_MANAGEMENT
- A_UINT32 nt_si_gen; /* gen# for scan indication*/
+ u32 nt_si_gen; /* gen# for scan indication*/
#endif
};
const u8 *macaddr)
{
int hash;
- A_UINT32 timeoutValue = 0;
+ u32 timeoutValue = 0;
A_MEMCPY(ni->ni_macaddr, macaddr, IEEE80211_ADDR_LEN);
hash = IEEE80211_NODE_HASH (macaddr);
void *arg)
{
bss_t *ni;
- A_UINT32 gen;
+ u32 gen;
gen = ++nt->nt_scangen;
}
void
-wlan_set_nodeage(struct ieee80211_node_table *nt, A_UINT32 nodeAge)
+wlan_set_nodeage(struct ieee80211_node_table *nt, u32 nodeAge)
{
nt->nt_nodeAge = nodeAge;
return;
#else
bss_t *bss, *nextBss;
u8 myBssid[IEEE80211_ADDR_LEN];
- A_UINT32 timeoutValue = 0;
- A_UINT32 now = A_GET_MS(0);
+ u32 timeoutValue = 0;
+ u32 now = A_GET_MS(0);
timeoutValue = nt->nt_nodeAge;
wmi_get_current_bssid(nt->nt_wmip, myBssid);
struct ieee80211_node_table *nt = (struct ieee80211_node_table *)arg;
bss_t *bss, *nextBss;
u8 myBssid[IEEE80211_ADDR_LEN], reArmTimer = false;
- A_UINT32 timeoutValue = 0;
+ u32 timeoutValue = 0;
timeoutValue = nt->nt_nodeAge;
bss_t *
wlan_find_Ssidnode (struct ieee80211_node_table *nt, A_UCHAR *pSsid,
- A_UINT32 ssidLength, bool bIsWPA2, bool bMatchSSID)
+ u32 ssidLength, bool bIsWPA2, bool bMatchSSID)
{
bss_t *ni = NULL;
A_UCHAR *pIESsid = NULL;
bss_t *
wlan_find_matching_Ssidnode (struct ieee80211_node_table *nt, A_UCHAR *pSsid,
- A_UINT32 ssidLength, A_UINT32 dot11AuthMode, A_UINT32 authMode,
- A_UINT32 pairwiseCryptoType, A_UINT32 grpwiseCryptoTyp)
+ u32 ssidLength, u32 dot11AuthMode, u32 authMode,
+ u32 pairwiseCryptoType, u32 grpwiseCryptoTyp)
{
bss_t *ni = NULL;
bss_t *best_ni = NULL;
((((u8 *)(p))[0] ) | (((u8 *)(p))[1] << 8)))
#define LE_READ_4(p) \
- ((A_UINT32) \
+ ((u32) \
((((u8 *)(p))[0] ) | (((u8 *)(p))[1] << 8) | \
(((u8 *)(p))[2] << 16) | (((u8 *)(p))[3] << 24)))
/*
* Converts MHz frequency to IEEE channel number.
*/
-A_UINT32
-wlan_freq2ieee(u16 freq)
+u32 wlan_freq2ieee(u16 freq)
{
if (freq == 2484)
return 14;
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, u8 *datap, A_UINT32 len);
+wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, u8 *datap, u32 len);
static int
-wmi_set_params_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len);
+wmi_set_params_event_rx(struct wmi_t *wmip, u8 *datap, u32 len);
static int
-wmi_acm_reject_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len);
+wmi_acm_reject_event_rx(struct wmi_t *wmip, u8 *datap, u32 len);
#ifdef CONFIG_HOST_GPIO_SUPPORT
static int wmi_gpio_intr_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);
-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);
+u8 ar6000_get_upper_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh, u32 size);
+u8 ar6000_get_lower_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh, u32 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);
}
-u8 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, u32 layer2Priority, bool wmmEnabled)
{
u8 *datap;
u8 trafficClass = WMM_AC_BE;
WMI_DATA_HDR *dtHdr;
u8 streamExists = 0;
u8 userPriority;
- A_UINT32 hdrsize, metasize;
+ u32 hdrsize, metasize;
ATH_LLC_SNAP_HDR *llcHdr;
WMI_CREATE_PSTREAM_CMD cmd;
{
if (processDot11Hdr)
{
- hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(A_UINT32));
+ hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(u32));
llcHdr = (ATH_LLC_SNAP_HDR *)(datap + sizeof(WMI_DATA_HDR) + metasize +
hdrsize);
ATH_MAC_HDR macHdr;
ATH_LLC_SNAP_HDR *llcHdr;
struct ieee80211_frame *wh;
- A_UINT32 hdrsize;
+ u32 hdrsize;
A_ASSERT(osbuf != NULL);
/* Make room for 802.11 hdr */
if (wmip->wmi_is_wmm_enabled)
{
- hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(A_UINT32));
+ hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(u32));
if (A_NETBUF_PUSH(osbuf, hdrsize) != A_OK)
{
return A_NO_MEMORY;
}
else
{
- hdrsize = A_ROUND_UP(sizeof(struct ieee80211_frame),sizeof(A_UINT32));
+ hdrsize = A_ROUND_UP(sizeof(struct ieee80211_frame),sizeof(u32));
if (A_NETBUF_PUSH(osbuf, hdrsize) != A_OK)
{
return A_NO_MEMORY;
u8 type,subtype;
ATH_LLC_SNAP_HDR *llcHdr;
ATH_MAC_HDR macHdr;
- A_UINT32 hdrsize;
+ u32 hdrsize;
A_ASSERT(osbuf != NULL);
datap = A_NETBUF_DATA(osbuf);
/* strip off the 802.11 hdr*/
if (subtype == IEEE80211_FC0_SUBTYPE_QOS) {
- hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(A_UINT32));
+ hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(u32));
A_NETBUF_PULL(osbuf, hdrsize);
} else if (subtype == IEEE80211_FC0_SUBTYPE_DATA) {
A_NETBUF_PULL(osbuf, sizeof(struct ieee80211_frame));
WMIX_CMD_HDR *cmd;
u16 id;
u8 *datap;
- A_UINT32 len;
+ u32 len;
int status = A_OK;
if (A_NETBUF_LEN(osbuf) < sizeof(WMIX_CMD_HDR)) {
/*
* Control Path
*/
-A_UINT32 cmdRecvNum;
+u32 cmdRecvNum;
int
wmi_control_rx(struct wmi_t *wmip, void *osbuf)
WMI_CMD_HDR *cmd;
u16 id;
u8 *datap;
- A_UINT32 len, i, loggingReq;
+ u32 len, i, loggingReq;
int status = A_OK;
A_ASSERT(osbuf != NULL);
}
#define LE_READ_4(p) \
- ((A_UINT32) \
+ ((u32) \
((((u8 *)(p))[0] ) | (((u8 *)(p))[1] << 8) | \
(((u8 *)(p))[2] << 16) | (((u8 *)(p))[3] << 24)))
bss_t *bss = NULL;
WMI_BSS_INFO_HDR *bih;
u8 *buf;
- A_UINT32 nodeCachingAllowed = 1;
+ u32 nodeCachingAllowed = 1;
A_UCHAR cached_ssid_len = 0;
A_UCHAR cached_ssid_buf[IEEE80211_NWID_LEN] = {0};
u8 beacon_ssid_len = 0;
{
WMI_BIT_RATE_REPLY *reply;
A_INT32 rate;
- A_UINT32 sgi,index;
+ u32 sgi,index;
/* 54149:
* WMI_BIT_RATE_CMD structure is changed to WMI_BIT_RATE_REPLY.
* since there is difference in the length and to avoid returning
static int
wmi_dbglog_event_rx(struct wmi_t *wmip, u8 *datap, int len)
{
- A_UINT32 dropped;
+ u32 dropped;
- dropped = *((A_UINT32 *)datap);
+ dropped = *((u32 *)datap);
datap += sizeof(dropped);
len -= sizeof(dropped);
A_WMI_DBGLOG_EVENT(wmip->wmi_devt, dropped, (A_INT8*)datap, len);
}
cHdr = (WMIX_CMD_HDR *)A_NETBUF_DATA(osbuf);
- cHdr->commandId = (A_UINT32) cmdId;
+ cHdr->commandId = (u32) cmdId;
return wmi_cmd_send(wmip, osbuf, WMI_EXTENSION_CMDID, syncflag);
}
CRYPTO_TYPE pairwiseCrypto, u8 pairwiseCryptoLen,
CRYPTO_TYPE groupCrypto, u8 groupCryptoLen,
int ssidLength, A_UCHAR *ssid,
- u8 *bssid, u16 channel, A_UINT32 ctrl_flags)
+ u8 *bssid, u16 channel, u32 ctrl_flags)
{
void *osbuf;
WMI_CONNECT_CMD *cc;
int
wmi_startscan_cmd(struct wmi_t *wmip, WMI_SCAN_TYPE scanType,
u32 forceFgScan, u32 isLegacy,
- A_UINT32 homeDwellTime, A_UINT32 forceScanInterval,
+ u32 homeDwellTime, u32 forceScanInterval,
A_INT8 numChan, u16 *channelList)
{
void *osbuf;
u16 minact_chdw_msec, u16 maxact_chdw_msec,
u16 pas_chdw_msec,
u8 shScanRatio, u8 scanCtrlFlags,
- A_UINT32 max_dfsch_act_time, u16 maxact_scan_per_ssid)
+ u32 max_dfsch_act_time, u16 maxact_scan_per_ssid)
{
void *osbuf;
WMI_SCAN_PARAMS_CMD *sc;
}
int
-wmi_bssfilter_cmd(struct wmi_t *wmip, u8 filter, A_UINT32 ieMask)
+wmi_bssfilter_cmd(struct wmi_t *wmip, u8 filter, u32 ieMask)
{
void *osbuf;
WMI_BSS_FILTER_CMD *cmd;
}
int
-wmi_apps_cmd(struct wmi_t *wmip, u8 psType, A_UINT32 idle_time,
- A_UINT32 ps_period, u8 sleep_period)
+wmi_apps_cmd(struct wmi_t *wmip, u8 psType, u32 idle_time,
+ u32 ps_period, u8 sleep_period)
{
void *osbuf;
WMI_AP_PS_CMD *cmd;
A_MEMCPY(cmd, params, sizeof(*cmd));
/* this is an implicitly created Fat pipe */
- if ((A_UINT32)params->tsid == (A_UINT32)WMI_IMPLICIT_PSTREAM) {
+ if ((u32)params->tsid == (u32)WMI_IMPLICIT_PSTREAM) {
LOCK_WMI(wmip);
fatPipeExistsForAC = (wmip->wmi_fatPipeExists & (1 << params->trafficClass));
wmip->wmi_fatPipeExists |= (1<<params->trafficClass);
for (i=0;;i++)
{
- if (wmi_rateTable[(A_UINT32) i][0] == 0) {
+ if (wmi_rateTable[(u32) i][0] == 0) {
return A_EINVAL;
}
- if (wmi_rateTable[(A_UINT32) i][0] == rate) {
+ if (wmi_rateTable[(u32) i][0] == rate) {
break;
}
}
}
int
-wmi_set_fixrates_cmd(struct wmi_t *wmip, A_UINT32 fixRatesMask)
+wmi_set_fixrates_cmd(struct wmi_t *wmip, u32 fixRatesMask)
{
void *osbuf;
WMI_FIX_RATES_CMD *cmd;
* to be used. */
/* Make sure all rates in the mask are valid in the current PHY mode */
for(rateIndex = 0; rateIndex < MAX_NUMBER_OF_SUPPORT_RATES; rateIndex++) {
- if((1 << rateIndex) & (A_UINT32)fixRatesMask) {
+ if((1 << rateIndex) & (u32)fixRatesMask) {
if(wmi_is_bitrate_index_valid(wmip, rateIndex) != true) {
A_DPRINTF(DBG_WMI, (DBGFMT "Set Fix Rates command failed: Given rate is illegal in current PHY mode\n", DBGARG));
return A_EINVAL;
}
int
-wmi_set_error_report_bitmask(struct wmi_t *wmip, A_UINT32 mask)
+wmi_set_error_report_bitmask(struct wmi_t *wmip, u32 mask)
{
void *osbuf;
A_INT8 size;
}
int
-wmi_get_challenge_resp_cmd(struct wmi_t *wmip, A_UINT32 cookie, A_UINT32 source)
+wmi_get_challenge_resp_cmd(struct wmi_t *wmip, u32 cookie, u32 source)
{
void *osbuf;
WMIX_HB_CHALLENGE_RESP_CMD *cmd;
int
wmi_config_debug_module_cmd(struct wmi_t *wmip, u16 mmask,
u16 tsr, bool rep, u16 size,
- A_UINT32 valid)
+ u32 valid)
{
void *osbuf;
WMIX_DBGLOG_CFG_MODULE_CMD *cmd;
wmi_get_roam_data_cmd(struct wmi_t *wmip, u8 roamDataType)
{
void *osbuf;
- A_UINT32 size = sizeof(u8);
+ u32 size = sizeof(u8);
WMI_TARGET_ROAM_DATA *cmd;
osbuf = A_NETBUF_ALLOC(size); /* no payload */
/* Send a command to Target to change GPIO output pins. */
int
wmi_gpio_output_set(struct wmi_t *wmip,
- A_UINT32 set_mask,
- A_UINT32 clear_mask,
- A_UINT32 enable_mask,
- A_UINT32 disable_mask)
+ u32 set_mask,
+ u32 clear_mask,
+ u32 enable_mask,
+ u32 disable_mask)
{
void *osbuf;
WMIX_GPIO_OUTPUT_SET_CMD *output_set;
/* Send a command to the Target that changes the value of a GPIO register. */
int
wmi_gpio_register_set(struct wmi_t *wmip,
- A_UINT32 gpioreg_id,
- A_UINT32 value)
+ u32 gpioreg_id,
+ u32 value)
{
void *osbuf;
WMIX_GPIO_REGISTER_SET_CMD *register_set;
/* Send a command to the Target to fetch the value of a GPIO register. */
int
wmi_gpio_register_get(struct wmi_t *wmip,
- A_UINT32 gpioreg_id)
+ u32 gpioreg_id)
{
void *osbuf;
WMIX_GPIO_REGISTER_GET_CMD *register_get;
/* Send a command to the Target acknowledging some GPIO interrupts. */
int
wmi_gpio_intr_ack(struct wmi_t *wmip,
- A_UINT32 ack_mask)
+ u32 ack_mask)
{
void *osbuf;
WMIX_GPIO_INTR_ACK_CMD *intr_ack;
u8 wmi_determine_userPriority(
u8 *pkt,
- A_UINT32 layer2Pri)
+ u32 layer2Pri)
{
u8 ipPri;
iphdr *ipHdr = (iphdr *)pkt;
have different test command requirements from differnt manufacturers
*/
int
-wmi_test_cmd(struct wmi_t *wmip, u8 *buf, A_UINT32 len)
+wmi_test_cmd(struct wmi_t *wmip, u8 *buf, u32 len)
{
void *osbuf;
char *data;
}
int
-wmi_set_params_cmd(struct wmi_t *wmip, A_UINT32 opcode, A_UINT32 length, char *buffer)
+wmi_set_params_cmd(struct wmi_t *wmip, u32 opcode, u32 length, char *buffer)
{
void *osbuf;
WMI_SET_PARAMS_CMD *cmd;
if (rateindex == RATE_AUTO) {
return 0;
} else {
- return(wmi_rateTable[(A_UINT32) rateindex][0]);
+ return(wmi_rateTable[(u32) rateindex][0]);
}
}
}
void
-wmi_set_nodeage(struct wmi_t *wmip, A_UINT32 nodeAge)
+wmi_set_nodeage(struct wmi_t *wmip, u32 nodeAge)
{
wlan_set_nodeage(&wmip->wmi_scan_table,nodeAge);
}
bss_t *
wmi_find_Ssidnode (struct wmi_t *wmip, A_UCHAR *pSsid,
- A_UINT32 ssidLength, bool bIsWPA2, bool bMatchSSID)
+ u32 ssidLength, bool bIsWPA2, bool bMatchSSID)
{
bss_t *node = NULL;
node = wlan_find_Ssidnode (&wmip->wmi_scan_table, pSsid,
int
wmi_dset_open_reply(struct wmi_t *wmip,
- A_UINT32 status,
- A_UINT32 access_cookie,
- A_UINT32 dset_size,
- A_UINT32 dset_version,
- A_UINT32 targ_handle,
- A_UINT32 targ_reply_fn,
- A_UINT32 targ_reply_arg)
+ u32 status,
+ u32 access_cookie,
+ u32 dset_size,
+ u32 dset_version,
+ u32 targ_handle,
+ u32 targ_reply_fn,
+ u32 targ_reply_arg)
{
void *osbuf;
WMIX_DSETOPEN_REPLY_CMD *open_reply;
}
static int
-wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len)
+wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, u8 *datap, u32 len)
{
WMI_PMKID_LIST_REPLY *reply;
- A_UINT32 expected_len;
+ u32 expected_len;
if (len < sizeof(WMI_PMKID_LIST_REPLY)) {
return A_EINVAL;
static int
-wmi_set_params_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len)
+wmi_set_params_event_rx(struct wmi_t *wmip, u8 *datap, u32 len)
{
WMI_SET_PARAMS_REPLY *reply;
static int
-wmi_acm_reject_event_rx(struct wmi_t *wmip, u8 *datap, A_UINT32 len)
+wmi_acm_reject_event_rx(struct wmi_t *wmip, u8 *datap, u32 len)
{
WMI_ACM_REJECT_EVENT *ev;
#ifdef CONFIG_HOST_DSET_SUPPORT
int
wmi_dset_data_reply(struct wmi_t *wmip,
- A_UINT32 status,
+ u32 status,
u8 *user_buf,
- A_UINT32 length,
- A_UINT32 targ_buf,
- A_UINT32 targ_reply_fn,
- A_UINT32 targ_reply_arg)
+ u32 length,
+ u32 targ_buf,
+ u32 targ_reply_fn,
+ u32 targ_reply_arg)
{
void *osbuf;
WMIX_DSETDATA_REPLY_CMD *data_reply;
- A_UINT32 size;
+ u32 size;
size = sizeof(*data_reply) + length;
#endif /* CONFIG_HOST_DSET_SUPPORT */
int
-wmi_set_wsc_status_cmd(struct wmi_t *wmip, A_UINT32 status)
+wmi_set_wsc_status_cmd(struct wmi_t *wmip, u32 status)
{
void *osbuf;
char *cmd;
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
int
wmi_prof_cfg_cmd(struct wmi_t *wmip,
- A_UINT32 period,
- A_UINT32 nbins)
+ u32 period,
+ u32 nbins)
{
void *osbuf;
WMIX_PROF_CFG_CMD *cmd;
}
int
-wmi_prof_addr_set_cmd(struct wmi_t *wmip, A_UINT32 addr)
+wmi_prof_addr_set_cmd(struct wmi_t *wmip, u32 addr)
{
void *osbuf;
WMIX_PROF_ADDR_SET_CMD *cmd;
wmi_scan_indication (struct wmi_t *wmip)
{
struct ieee80211_node_table *nt;
- A_UINT32 gen;
- A_UINT32 size;
- A_UINT32 bsssize;
+ u32 gen;
+ u32 size;
+ u32 bsssize;
bss_t *bss;
- A_UINT32 numbss;
+ u32 numbss;
PNDIS_802_11_BSSID_SCAN_INFO psi;
PBYTE pie;
NDIS_802_11_FIXED_IEs *pFixed;
NDIS_802_11_VARIABLE_IEs *pVar;
- A_UINT32 RateSize;
+ u32 RateSize;
struct ar6kScanIndication
{
#endif
u8 ar6000_get_upper_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh,
- A_UINT32 size)
+ u32 size)
{
- A_UINT32 index;
+ u32 index;
u8 threshold = (u8)sq_thresh->upper_threshold[size - 1];
/* The list is already in sorted order. Get the next lower value */
}
u8 ar6000_get_lower_threshold(A_INT16 rssi, SQ_THRESHOLD_PARAMS *sq_thresh,
- A_UINT32 size)
+ u32 size)
{
- A_UINT32 index;
+ u32 index;
u8 threshold = (u8)sq_thresh->lower_threshold[size - 1];
/* The list is already in sorted order. Get the next lower value */
}
int
-wmi_ap_conn_inact_time(struct wmi_t *wmip, A_UINT32 period)
+wmi_ap_conn_inact_time(struct wmi_t *wmip, u32 period)
{
WMI_AP_CONN_INACT_CMD *cmd;
void *osbuf = NULL;
}
int
-wmi_ap_bgscan_time(struct wmi_t *wmip, A_UINT32 period, A_UINT32 dwell)
+wmi_ap_bgscan_time(struct wmi_t *wmip, u32 period, u32 dwell)
{
WMI_AP_PROT_SCAN_TIME_CMD *cmd;
void *osbuf = NULL;
#endif
int
-wmi_set_tx_select_rates_cmd(struct wmi_t *wmip, A_UINT32 *pMaskArray)
+wmi_set_tx_select_rates_cmd(struct wmi_t *wmip, u32 *pMaskArray)
{
void *osbuf;
WMI_SET_TX_SELECT_RATES_CMD *pData;
}
int
-wmi_SGI_cmd(struct wmi_t *wmip, A_UINT32 sgiMask, u8 sgiPERThreshold)
+wmi_SGI_cmd(struct wmi_t *wmip, u32 sgiMask, u8 sgiPERThreshold)
{
void *osbuf;
WMI_SET_TX_SGI_PARAM_CMD *cmd;
bss_t *
wmi_find_matching_Ssidnode (struct wmi_t *wmip, A_UCHAR *pSsid,
- A_UINT32 ssidLength,
- A_UINT32 dot11AuthMode, A_UINT32 authMode,
- A_UINT32 pairwiseCryptoType, A_UINT32 grpwiseCryptoTyp)
+ u32 ssidLength,
+ u32 dot11AuthMode, u32 authMode,
+ u32 pairwiseCryptoType, u32 grpwiseCryptoTyp)
{
bss_t *node = NULL;
node = wlan_find_matching_Ssidnode (&wmip->wmi_scan_table, pSsid,
}
-A_UINT32
-wmi_freq2ieee (u16 freq)
+u32 wmi_freq2ieee (u16 freq)
{
u16 chan = 0;
chan = wlan_freq2ieee (freq);
#endif
struct wmi_stats {
- A_UINT32 cmd_len_err;
- A_UINT32 cmd_id_err;
+ u32 cmd_len_err;
+ u32 cmd_id_err;
};
#define SSID_IE_LEN_INDEX 13
typedef struct sq_threshold_params_s {
A_INT16 upper_threshold[SIGNAL_QUALITY_UPPER_THRESHOLD_LEVELS];
A_INT16 lower_threshold[SIGNAL_QUALITY_LOWER_THRESHOLD_LEVELS];
- A_UINT32 upper_threshold_valid_count;
- A_UINT32 lower_threshold_valid_count;
- A_UINT32 polling_interval;
+ u32 upper_threshold_valid_count;
+ u32 lower_threshold_valid_count;
+ u32 polling_interval;
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
projects / GitHub / MotorolaMobilityLLC / kernel-slsi.git / commitdiff