Use the in-kernel u32 type instead.
Cc: Mikko Virkkilä <mikko.virkkila@bluegiga.com>
Cc: Lauri Hintsala <Lauri.Hintsala@bluegiga.com>
Cc: Riku Mettälä <riku.mettala@bluegiga.com>
Cc: Veli-Pekka Peltola <veli-pekka.peltola@bluegiga.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
unifi_priv_t *priv = (unifi_priv_t*)arg;
CsrResult csrResult;
long ret;
- CsrUint32 timeout, t;
+ u32 timeout, t;
struct uf_thread *this_thread;
unifi_trace(priv, UDBG2, "bh_thread_function starting\n");
* CSR_FE_RESULT_INVALID_POINTER in case the eventBits pointer is invalid
*
*----------------------------------------------------------------------------*/
-CsrResult CsrEventWait(CsrEventHandle *eventHandle, u16 timeoutInMs, CsrUint32 *eventBits);
+CsrResult CsrEventWait(CsrEventHandle *eventHandle, u16 timeoutInMs, u32 *eventBits);
/*----------------------------------------------------------------------------*
* NAME
* CSR_FE_RESULT_INVALID_HANDLE in case the eventHandle is invalid
*
*----------------------------------------------------------------------------*/
-CsrResult CsrEventSet(CsrEventHandle *eventHandle, CsrUint32 eventBits);
+CsrResult CsrEventSet(CsrEventHandle *eventHandle, u32 eventBits);
/*----------------------------------------------------------------------------*
* NAME
*
*----------------------------------------------------------------------------*/
CsrResult CsrThreadCreate(void (*threadFunction)(void *pointer), void *pointer,
- CsrUint32 stackSize, u16 priority,
+ u32 stackSize, u16 priority,
const CsrCharString *threadName, CsrThreadHandle *threadHandle);
/*----------------------------------------------------------------------------*
*----------------------------------------------------------------------------*/
#ifdef CSR_MEM_DEBUG
void *CsrMemAllocDebug(CsrSize size,
- const CsrCharString *file, CsrUint32 line);
+ const CsrCharString *file, u32 line);
#define CsrMemAlloc(sz) CsrMemAllocDebug((sz), __FILE__, __LINE__)
#else
void *CsrMemAlloc(CsrSize size);
*----------------------------------------------------------------------------*/
#ifdef CSR_MEM_DEBUG
void *CsrMemCallocDebug(CsrSize numberOfElements, CsrSize elementSize,
- const CsrCharString *file, CsrUint32 line);
+ const CsrCharString *file, u32 line);
#define CsrMemCalloc(cnt, sz) CsrMemAllocDebug((cnt), (sz), __FILE__, __LINE__)
#else
void *CsrMemCalloc(CsrSize numberOfElements, CsrSize elementSize);
*----------------------------------------------------------------------------*/
#ifdef CSR_MEM_DEBUG
void *CsrMemAllocDmaDebug(CsrSize size,
- const CsrCharString *file, CsrUint32 line);
+ const CsrCharString *file, u32 line);
#define CsrMemAllocDma(sz) CsrMemAllocDmaDebug((sz), __FILE__, __LINE__)
#else
void *CsrMemAllocDma(CsrSize size);
{
pthread_cond_t event;
pthread_mutex_t mutex;
- CsrUint32 eventBits;
+ u32 eventBits;
};
typedef struct CsrEvent CsrEventHandle;
{
CsrPrim type;
u16 value1;
- CsrUint32 value2;
+ u32 value2;
} CsrEventCsrUint16CsrUint32;
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrEventCsrUint16
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrUint32 *CsrEventCsrUint16CsrUint32_struct(u16 primtype, u16 msgtype, u16 value1, CsrUint32 value2);
+CsrEventCsrUint16CsrUint32 *CsrEventCsrUint16CsrUint32_struct(u16 primtype, u16 msgtype, u16 value1, u32 value2);
typedef struct
{
typedef struct
{
CsrPrim type;
- CsrUint32 value;
+ u32 value;
} CsrEventCsrUint32;
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrEventCsrUint32
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint32 *CsrEventCsrUint32_struct(u16 primtype, u16 msgtype, CsrUint32 value);
+CsrEventCsrUint32 *CsrEventCsrUint32_struct(u16 primtype, u16 msgtype, u32 value);
typedef struct
{
CsrPrim type;
- CsrUint32 value1;
+ u32 value1;
u16 value2;
} CsrEventCsrUint32CsrUint16;
* Allocates and fills in a message with the signature CsrEventCsrUint32CsrUint16
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint32CsrUint16 *CsrEventCsrUint32CsrUint16_struct(u16 primtype, u16 msgtype, CsrUint32 value1, CsrUint32 value2);
+CsrEventCsrUint32CsrUint16 *CsrEventCsrUint32CsrUint16_struct(u16 primtype, u16 msgtype, u32 value1, u32 value2);
typedef struct
{
CsrPrim type;
- CsrUint32 value1;
+ u32 value1;
CsrCharString *value2;
} CsrEventCsrUint32CsrCharString;
* Allocates and fills in a message with the signature CsrEventCsrUint32CsrCharString
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint32CsrCharString *CsrEventCsrUint32CsrCharString_struct(u16 primtype, u16 msgtype, CsrUint32 value1, CsrCharString *value2);
+CsrEventCsrUint32CsrCharString *CsrEventCsrUint32CsrCharString_struct(u16 primtype, u16 msgtype, u32 value1, CsrCharString *value2);
#ifdef __cplusplus
}
/*----------------------------------------------------*/
/* Filtering on environment specific log levels */
/*----------------------------------------------------*/
-typedef CsrUint32 CsrLogLevelEnvironment;
+typedef u32 CsrLogLevelEnvironment;
#define CSR_LOG_LEVEL_ENVIRONMENT_OFF ((CsrLogLevelEnvironment) 0x00000000) /* No environment data/events are logged */
#define CSR_LOG_LEVEL_ENVIRONMENT_BCI_ACL ((CsrLogLevelEnvironment) 0x00000001) /* BlueCore Channel Interface HCI Acl data are logged */
#define CSR_LOG_LEVEL_ENVIRONMENT_BCI_HCI ((CsrLogLevelEnvironment) 0x00000002) /* BlueCore Channel Interface HCI Cmd/Evt data are logged */
/*----------------------------------------------------*/
/* Filtering on task specific log levels */
/*----------------------------------------------------*/
-typedef CsrUint32 CsrLogLevelTask;
+typedef u32 CsrLogLevelTask;
#define CSR_LOG_LEVEL_TASK_OFF ((CsrLogLevelTask) 0x00000000) /* No events are logged for this task */
#define CSR_LOG_LEVEL_TASK_TEXT ((CsrLogLevelTask) 0x00000001) /* Text strings printed by a task are logged NB: This bit does not affect the CSR_LOG_TEXT_LEVEL interface. This has to be configured separately */
#define CSR_LOG_LEVEL_TASK_TEXT_LOC ((CsrLogLevelTask) 0x00000002) /* The locaction where the text string call occured are logged. NB: This is a supplement to CSR_LOG_LEVEL_TASK_TEXT, it has no effect without it */
typedef struct
{
const CsrCharString *techVer;
- CsrUint32 primitiveInfoCount;
+ u32 primitiveInfoCount;
CsrLogPrimitiveInformation *primitiveInfo;
} CsrLogTechInformation;
/*---------------------------------*/
typedef u8 bitmask8_t;
typedef u16 bitmask16_t;
-typedef CsrUint32 bitmask32_t;
+typedef u32 bitmask32_t;
#ifdef CSR_LOG_ENABLE
#ifdef CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER
/* DEPRECATED - replaced by csr_log_text.h */
void CsrLogTaskText(const CsrCharString *text,
- CsrUint32 line,
+ u32 line,
const CsrCharString *file);
#define CSR_LOG_STATE_TRANSITION_MASK_FSM_NAME (0x001)
/* DEPRECATED - replaced by csr_log_text.h */
void CsrLogStateTransition(bitmask16_t mask,
- CsrUint32 identifier,
+ u32 identifier,
const CsrCharString *fsm_name,
- CsrUint32 prev_state,
+ u32 prev_state,
const CsrCharString *prev_state_str,
- CsrUint32 in_event,
+ u32 in_event,
const CsrCharString *in_event_str,
- CsrUint32 next_state,
+ u32 next_state,
const CsrCharString *next_state_str,
- CsrUint32 line,
+ u32 line,
const CsrCharString *file);
/*---------------------------------*/
#define SYNERGY_SERIALIZER_TYPE_DUMP (0x000)
#define SYNERGY_SERIALIZER_TYPE_SER (0x001)
-void CsrLogMessagePut(CsrUint32 line,
+void CsrLogMessagePut(u32 line,
const CsrCharString *file,
CsrSchedQid src_task_id,
CsrSchedQid dst_taskid,
u16 prim_type,
const void *msg);
-void CsrLogTimedEventIn(CsrUint32 line,
+void CsrLogTimedEventIn(u32 line,
const CsrCharString *file,
CsrSchedQid task_id,
CsrSchedTid tid,
void CsrLogTimedEventDone(CsrSchedQid task_id,
CsrSchedTid tid);
-void CsrLogTimedEventCancel(CsrUint32 line,
+void CsrLogTimedEventCancel(u32 line,
const CsrCharString *file,
CsrSchedQid task_id,
CsrSchedTid tid,
void CsrLogExceptionStateEvent(u16 prim_type,
CsrPrim msg_type,
u16 state,
- CsrUint32 line,
+ u32 line,
const CsrCharString *file);
void CsrLogExceptionGeneral(u16 prim_type,
u16 state,
const CsrCharString *text,
- CsrUint32 line,
+ u32 line,
const CsrCharString *file);
void CsrLogExceptionWarning(u16 prim_type,
u16 state,
const CsrCharString *text,
- CsrUint32 line,
+ u32 line,
const CsrCharString *file);
#ifdef __cplusplus
/*--------------------------------------------*/
/* Filtering on log text warning levels */
/*--------------------------------------------*/
-typedef CsrUint32 CsrLogLevelText;
+typedef u32 CsrLogLevelText;
#define CSR_LOG_LEVEL_TEXT_OFF ((CsrLogLevelText) 0x0000)
#define CSR_LOG_LEVEL_TEXT_CRITICAL ((CsrLogLevelText) 0x0001)
* clashes the technologies are only allowed to assign values within the same restrictive range as allies to
* primitive identifiers. eg. for the framework components outside the scheduler is only allowed to assign
* taskId's in the range 0x0600xxxx to 0x06FFxxxx. And so on for other technologies. */
-typedef CsrUint32 CsrLogTextTaskId;
+typedef u32 CsrLogTextTaskId;
/* Set the text logging level for all Tasks */
/* This function call takes precedence over all previous calls to CsrLogLevelTextSetTask() and CsrLogLevelTextSetTaskSubOrigin() */
#endif
/*------------------------------------------------------------------*/
-/* Bits - intended to operate on CsrUint32 values */
+/* Bits - intended to operate on u32 values */
/*------------------------------------------------------------------*/
#define CSR_MASK_IS_SET(val, mask) (((val) & (mask)) == (mask))
#define CSR_MASK_IS_UNSET(val, mask) ((((val) & (mask)) ^ mask) == (mask))
/* Endian conversion */
/*------------------------------------------------------------------*/
#define CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr) (((u16) ((u8 *) (ptr))[0]) | ((u16) ((u8 *) (ptr))[1]) << 8)
-#define CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr) (((CsrUint32) ((u8 *) (ptr))[0]) | ((CsrUint32) ((u8 *) (ptr))[1]) << 8 | \
- ((CsrUint32) ((u8 *) (ptr))[2]) << 16 | ((CsrUint32) ((u8 *) (ptr))[3]) << 24)
+#define CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr) (((u32) ((u8 *) (ptr))[0]) | ((u32) ((u8 *) (ptr))[1]) << 8 | \
+ ((u32) ((u8 *) (ptr))[2]) << 16 | ((u32) ((u8 *) (ptr))[3]) << 24)
#define CSR_COPY_UINT16_TO_LITTLE_ENDIAN(uint, ptr) ((u8 *) (ptr))[0] = ((u8) ((uint) & 0x00FF)); \
((u8 *) (ptr))[1] = ((u8) ((uint) >> 8))
#define CSR_COPY_UINT32_TO_LITTLE_ENDIAN(uint, ptr) ((u8 *) (ptr))[0] = ((u8) ((uint) & 0x000000FF)); \
#define CSR_GET_UINT16_FROM_BIG_ENDIAN(ptr) (((u16) ((u8 *) (ptr))[1]) | ((u16) ((u8 *) (ptr))[0]) << 8)
#define CSR_GET_UINT24_FROM_BIG_ENDIAN(ptr) (((CsrUint24) ((u8 *) (ptr))[2]) | \
((CsrUint24) ((u8 *) (ptr))[1]) << 8 | ((CsrUint24) ((u8 *) (ptr))[0]) << 16)
-#define CSR_GET_UINT32_FROM_BIG_ENDIAN(ptr) (((CsrUint32) ((u8 *) (ptr))[3]) | ((CsrUint32) ((u8 *) (ptr))[2]) << 8 | \
- ((CsrUint32) ((u8 *) (ptr))[1]) << 16 | ((CsrUint32) ((u8 *) (ptr))[0]) << 24)
+#define CSR_GET_UINT32_FROM_BIG_ENDIAN(ptr) (((u32) ((u8 *) (ptr))[3]) | ((u32) ((u8 *) (ptr))[2]) << 8 | \
+ ((u32) ((u8 *) (ptr))[1]) << 16 | ((u32) ((u8 *) (ptr))[0]) << 24)
#define CSR_COPY_UINT16_TO_BIG_ENDIAN(uint, ptr) ((u8 *) (ptr))[1] = ((u8) ((uint) & 0x00FF)); \
((u8 *) (ptr))[0] = ((u8) ((uint) >> 8))
#define CSR_COPY_UINT24_TO_BIG_ENDIAN(uint, ptr) ((u8 *) (ptr))[2] = ((u8) ((uint) & 0x000000FF)); \
((u16) (input)[0]));(input) += 2
#define CSR_CONVERT_32_FROM_XAP(output, input) \
- (output) = (((CsrUint32) (input)[1]) << 24) | \
- (((CsrUint32) (input)[0]) << 16) | \
- (((CsrUint32) (input)[3]) << 8) | \
- ((CsrUint32) (input)[2]);input += 4
+ (output) = (((u32) (input)[1]) << 24) | \
+ (((u32) (input)[0]) << 16) | \
+ (((u32) (input)[3]) << 8) | \
+ ((u32) (input)[2]);input += 4
#define CSR_ADD_UINT8_TO_XAP(output, input) \
(output)[0] = (input); \
/* SHOULD BE INTERNAL TO FRAMEWORK AKA DEPRECATED */
-CsrUint32 CsrCharStringSerLen(const CsrCharString *str);
-CsrUint32 CsrUtf8StringSerLen(const CsrUtf8String *str);
-CsrUint32 CsrUtf16StringSerLen(const CsrUtf16String *str);
+u32 CsrCharStringSerLen(const CsrCharString *str);
+u32 CsrUtf8StringSerLen(const CsrUtf8String *str);
+u32 CsrUtf16StringSerLen(const CsrUtf16String *str);
/* Prototypes for primitive type serializers */
void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value);
void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value);
-void CsrUint32Ser(u8 *buffer, CsrSize *offset, CsrUint32 value);
+void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value);
void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length);
void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value);
void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value);
void CsrUint8Des(u8 *value, u8 *buffer, CsrSize *offset);
void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset);
-void CsrUint32Des(CsrUint32 *value, u8 *buffer, CsrSize *offset);
+void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset);
void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length);
void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset);
void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset);
*****************************************************************************/
#ifdef CSR_PMEM_DEBUG
void *CsrPmemAllocDebug(CsrSize size,
- const CsrCharString *file, CsrUint32 line);
+ const CsrCharString *file, u32 line);
#define CsrPmemAlloc(sz) CsrPmemAllocDebug((sz), __FILE__, __LINE__)
#else
void *CsrPmemAlloc(CsrSize size);
#define CSR_PMEM_DEBUG_TYPE_MEM_CALLOC 3
#define CSR_PMEM_DEBUG_TYPE_MEM_ALLOC_DMA 4
-typedef void (CsrPmemDebugOnAlloc)(void *ptr, void *userptr, CsrSize size, CsrPmemDebugAllocType type, const CsrCharString* file, CsrUint32 line);
-typedef void (CsrPmemDebugOnFree)(void *ptr, void *userptr, CsrPmemDebugAllocType type, const CsrCharString* file, CsrUint32 line);
+typedef void (CsrPmemDebugOnAlloc)(void *ptr, void *userptr, CsrSize size, CsrPmemDebugAllocType type, const CsrCharString* file, u32 line);
+typedef void (CsrPmemDebugOnFree)(void *ptr, void *userptr, CsrPmemDebugAllocType type, const CsrCharString* file, u32 line);
/*----------------------------------------------------------------------------*
* NAME
*----------------------------------------------------------------------------*/
void CsrPmemDebugInstallHooks(u8 headSize, u8 endSize, CsrPmemDebugOnAlloc *onAllocCallback, CsrPmemDebugOnFree *onFreeCallback);
-void *CsrPmemDebugAlloc(CsrSize size, CsrPmemDebugAllocType type, const CsrCharString* file, CsrUint32 line);
+void *CsrPmemDebugAlloc(CsrSize size, CsrPmemDebugAllocType type, const CsrCharString* file, u32 line);
#define CsrPmemAlloc(size) CsrPmemDebugAlloc(size, CSR_PMEM_DEBUG_TYPE_PMEM_ALLOC, __FILE__, __LINE__)
-void CsrPmemDebugFree(void *ptr, CsrPmemDebugAllocType type, const CsrCharString* file, CsrUint32 line);
+void CsrPmemDebugFree(void *ptr, CsrPmemDebugAllocType type, const CsrCharString* file, u32 line);
#define CsrPmemFree(ptr) CsrPmemDebugFree(ptr, CSR_PMEM_DEBUG_TYPE_PMEM_ALLOC, __FILE__, __LINE__)
#endif
#endif
/* An identifier issued by the scheduler. */
-typedef CsrUint32 CsrSchedIdentifier;
+typedef u32 CsrSchedIdentifier;
/* A task identifier */
typedef u16 CsrSchedTaskId;
void CsrSchedMessagePutStringLog(CsrSchedQid q,
u16 mi,
void *mv,
- CsrUint32 line,
+ u32 line,
const CsrCharString *file);
#define CsrSchedMessagePut(q, mi, mv) CsrSchedMessagePutStringLog((q), (mi), (mv), __LINE__, __FILE__)
#else
void CsrSchedMessageBroadcastStringLog(u16 mi,
void *(*msg_build_func)(void *),
void *msg_build_ptr,
- CsrUint32 line,
+ u32 line,
const CsrCharString *file);
#define CsrSchedMessageBroadcast(mi, fn, ptr) CsrSchedMessageBroadcastStringLog((mi), (fn), (ptr), __LINE__, __FILE__)
#else
void (*fn)(u16 mi, void *mv),
u16 fniarg,
void *fnvarg,
- CsrUint32 line,
+ u32 line,
const CsrCharString *file);
#define CsrSchedTimerSet(d, fn, fni, fnv) CsrSchedTimerSetStringLog((d), (fn), (fni), (fnv), __LINE__, __FILE__)
#else
CsrBool CsrSchedTimerCancelStringLog(CsrSchedTid eventid,
u16 *pmi,
void **pmv,
- CsrUint32 line,
+ u32 line,
const CsrCharString *file);
#define CsrSchedTimerCancel(e, pmi, pmv) CsrSchedTimerCancelStringLog((e), (pmi), (pmv), __LINE__, __FILE__)
#else
{
CsrSdioFunctionId sdioId;
u16 blockSize; /* Actual configured block size, or 0 if unconfigured */
- CsrUint32 features; /* Bit mask with any of CSR_SDIO_FEATURE_* set */
+ u32 features; /* Bit mask with any of CSR_SDIO_FEATURE_* set */
void *device; /* Handle of device containing the function */
void *driverData; /* For use by the Function Driver */
void *priv; /* For use by the SDIO Driver */
*
*
*----------------------------------------------------------------------------*/
-CsrResult CsrSdioMaxBusClockFrequencySet(CsrSdioFunction *function, CsrUint32 maxFrequency);
+CsrResult CsrSdioMaxBusClockFrequencySet(CsrSdioFunction *function, u32 maxFrequency);
/*----------------------------------------------------------------------------*
* NAME
* the callback function.
*
*----------------------------------------------------------------------------*/
-CsrResult CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, u8 *data);
-CsrResult CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, u8 data);
-void CsrSdioRead8Async(CsrSdioFunction *function, CsrUint32 address, u8 *data, CsrSdioAsyncCallback callback);
-void CsrSdioWrite8Async(CsrSdioFunction *function, CsrUint32 address, u8 data, CsrSdioAsyncCallback callback);
+CsrResult CsrSdioRead8(CsrSdioFunction *function, u32 address, u8 *data);
+CsrResult CsrSdioWrite8(CsrSdioFunction *function, u32 address, u8 data);
+void CsrSdioRead8Async(CsrSdioFunction *function, u32 address, u8 *data, CsrSdioAsyncCallback callback);
+void CsrSdioWrite8Async(CsrSdioFunction *function, u32 address, u8 data, CsrSdioAsyncCallback callback);
/*----------------------------------------------------------------------------*
* NAME
* the callback function.
*
*----------------------------------------------------------------------------*/
-CsrResult CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, u16 *data);
-CsrResult CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, u16 data);
-void CsrSdioRead16Async(CsrSdioFunction *function, CsrUint32 address, u16 *data, CsrSdioAsyncCallback callback);
-void CsrSdioWrite16Async(CsrSdioFunction *function, CsrUint32 address, u16 data, CsrSdioAsyncCallback callback);
+CsrResult CsrSdioRead16(CsrSdioFunction *function, u32 address, u16 *data);
+CsrResult CsrSdioWrite16(CsrSdioFunction *function, u32 address, u16 data);
+void CsrSdioRead16Async(CsrSdioFunction *function, u32 address, u16 *data, CsrSdioAsyncCallback callback);
+void CsrSdioWrite16Async(CsrSdioFunction *function, u32 address, u16 data, CsrSdioAsyncCallback callback);
/*----------------------------------------------------------------------------*
* NAME
* the callback function.
*
*----------------------------------------------------------------------------*/
-CsrResult CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, u8 *data);
-CsrResult CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, u8 data);
-void CsrSdioF0Read8Async(CsrSdioFunction *function, CsrUint32 address, u8 *data, CsrSdioAsyncCallback callback);
-void CsrSdioF0Write8Async(CsrSdioFunction *function, CsrUint32 address, u8 data, CsrSdioAsyncCallback callback);
+CsrResult CsrSdioF0Read8(CsrSdioFunction *function, u32 address, u8 *data);
+CsrResult CsrSdioF0Write8(CsrSdioFunction *function, u32 address, u8 data);
+void CsrSdioF0Read8Async(CsrSdioFunction *function, u32 address, u8 *data, CsrSdioAsyncCallback callback);
+void CsrSdioF0Write8Async(CsrSdioFunction *function, u32 address, u8 data, CsrSdioAsyncCallback callback);
/*----------------------------------------------------------------------------*
* NAME
* the callback function.
*
*----------------------------------------------------------------------------*/
-CsrResult CsrSdioRead(CsrSdioFunction *function, CsrUint32 address, void *data, CsrUint32 length);
-CsrResult CsrSdioWrite(CsrSdioFunction *function, CsrUint32 address, const void *data, CsrUint32 length);
-void CsrSdioReadAsync(CsrSdioFunction *function, CsrUint32 address, void *data, CsrUint32 length, CsrSdioAsyncCallback callback);
-void CsrSdioWriteAsync(CsrSdioFunction *function, CsrUint32 address, const void *data, CsrUint32 length, CsrSdioAsyncCallback callback);
+CsrResult CsrSdioRead(CsrSdioFunction *function, u32 address, void *data, u32 length);
+CsrResult CsrSdioWrite(CsrSdioFunction *function, u32 address, const void *data, u32 length);
+void CsrSdioReadAsync(CsrSdioFunction *function, u32 address, void *data, u32 length, CsrSdioAsyncCallback callback);
+void CsrSdioWriteAsync(CsrSdioFunction *function, u32 address, const void *data, u32 length, CsrSdioAsyncCallback callback);
/*----------------------------------------------------------------------------*
* NAME
}
EXPORT_SYMBOL_GPL(CsrUint16Des);
-void CsrUint32Des(CsrUint32 *value, u8 *buffer, CsrSize *offset)
+void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset)
{
*value = (buffer[*offset + 0] << 0) |
(buffer[*offset + 1] << 8) |
void CsrUtf16StringDes(CsrUtf16String **value, u8 *buffer, CsrSize *offset)
{
- CsrUint32 length, i;
+ u32 length, i;
CsrUint32Des(&length, buffer, offset);
}
EXPORT_SYMBOL_GPL(CsrUint16Ser);
-void CsrUint32Ser(u8 *buffer, CsrSize *offset, CsrUint32 value)
+void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value)
{
buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
{
if (value)
{
- CsrUint32 length = CsrUtf16StrLen(value) + 1;
- CsrUint32 i;
+ u32 length = CsrUtf16StrLen(value) + 1;
+ u32 i;
CsrUint32Ser(buffer, offset, length);
CsrSizeSer(buffer, offset, (CsrSize) ptr);
}
-CsrUint32 CsrCharStringSerLen(const CsrCharString *str)
+u32 CsrCharStringSerLen(const CsrCharString *str)
{
if (str)
{
- return (CsrUint32) (CsrStrLen(str) + sizeof(*str));
+ return (u32) (CsrStrLen(str) + sizeof(*str));
}
else
{
}
}
-CsrUint32 CsrUtf8StringSerLen(const CsrUtf8String *str)
+u32 CsrUtf8StringSerLen(const CsrUtf8String *str)
{
if (str)
{
- return (CsrUint32) (CsrStrLen((CsrCharString *) str) + sizeof(*str));
+ return (u32) (CsrStrLen((CsrCharString *) str) + sizeof(*str));
}
else
{
}
}
-CsrUint32 CsrUtf16StringSerLen(const CsrUtf16String *str)
+u32 CsrUtf16StringSerLen(const CsrUtf16String *str)
{
if (str)
{
/* We always write down the length of the string */
- return sizeof(CsrUint32) + (CsrUtf16StrLen(str) + 1) * sizeof(*str);
+ return sizeof(u32) + (CsrUtf16StrLen(str) + 1) * sizeof(*str);
}
else
{
- return sizeof(CsrUint32);
+ return sizeof(u32);
}
}
reference, usually associated with system startup.
*******************************************************************************/
-typedef CsrUint32 CsrTime;
+typedef u32 CsrTime;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint32 sec;
+ u32 sec;
u16 msec;
} CsrTimeUtc;
typedef uintptr_t CsrUintptr; /* Unsigned integer large enough to hold any pointer (ISO/IEC 9899:1999 7.18.1.4) */
typedef ptrdiff_t CsrIntptr; /* intptr_t is not defined in kernel. Use the equivalent ptrdiff_t. */
-/* Unsigned fixed width types */
-typedef uint32_t CsrUint32;
-
/* Signed fixed width types */
typedef int32_t CsrInt32;
typedef char CsrCharString;
typedef u8 CsrUtf8String;
typedef u16 CsrUtf16String; /* 16-bit UTF16 strings */
-typedef CsrUint32 CsrUint24;
+typedef u32 CsrUint24;
/*
* 64-bit integers
extern "C" {
#endif
-CsrUtf16String *CsrUint32ToUtf16String(CsrUint32 number);
+CsrUtf16String *CsrUint32ToUtf16String(u32 number);
-CsrUint32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString);
-CsrUint32 CsrUtf16StrLen(const CsrUtf16String *unicodeString);
+u32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString);
+u32 CsrUtf16StrLen(const CsrUtf16String *unicodeString);
CsrUtf8String *CsrUtf16String2Utf8(const CsrUtf16String *source);
CsrUtf16String *CsrUtf16StringDuplicate(const CsrUtf16String *source);
u16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2);
-u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count);
+u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, u32 count);
-CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, CsrUint32 count);
+CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, u32 count);
CsrUtf16String *CsrUtf16ConcatenateTexts(const CsrUtf16String *inputText1, const CsrUtf16String *inputText2,
const CsrUtf16String *inputText3, const CsrUtf16String *inputText4);
CsrInt32 CsrUtf8StrCmp(const CsrUtf8String *string1, const CsrUtf8String *string2);
CsrInt32 CsrUtf8StrNCmp(const CsrUtf8String *string1, const CsrUtf8String *string2, CsrSize count);
-CsrUint32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string);
+u32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string);
/*******************************************************************************
#include "csr_unicode.h"
#include "csr_util.h"
-#define UNI_SUR_HIGH_START ((CsrUint32) 0xD800)
-#define UNI_SUR_HIGH_END ((CsrUint32) 0xDBFF)
-#define UNI_SUR_LOW_START ((CsrUint32) 0xDC00)
-#define UNI_SUR_LOW_END ((CsrUint32) 0xDFFF)
-#define UNI_REPLACEMENT_CHAR ((CsrUint32) 0xFFFD)
+#define UNI_SUR_HIGH_START ((u32) 0xD800)
+#define UNI_SUR_HIGH_END ((u32) 0xDBFF)
+#define UNI_SUR_LOW_START ((u32) 0xDC00)
+#define UNI_SUR_LOW_END ((u32) 0xDFFF)
+#define UNI_REPLACEMENT_CHAR ((u32) 0xFFFD)
#define UNI_HALF_SHIFT ((u8) 10) /* used for shifting by 10 bits */
-#define UNI_HALF_BASE ((CsrUint32) 0x00010000)
-#define UNI_BYTEMASK ((CsrUint32) 0xBF)
-#define UNI_BYTEMARK ((CsrUint32) 0x80)
+#define UNI_HALF_BASE ((u32) 0x00010000)
+#define UNI_BYTEMASK ((u32) 0xBF)
+#define UNI_BYTEMARK ((u32) 0x80)
#define CAPITAL(x) ((x >= 'a') && (x <= 'z') ? ((x) & 0x00DF) : (x))
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xE0 - 0xFF */
};
-/* Values to be substracted from a CsrUint32 when converting from UTF8 to UTF16 */
-static const CsrUint32 offsetsFromUtf8[4] =
+/* Values to be substracted from a u32 when converting from UTF8 to UTF16 */
+static const u32 offsetsFromUtf8[4] =
{
0x00000000, 0x00003080, 0x000E2080, 0x03C82080
};
* Output: A string of UTF-16 characters.
*
*********************************************************************************/
-CsrUtf16String *CsrUint32ToUtf16String(CsrUint32 number)
+CsrUtf16String *CsrUint32ToUtf16String(u32 number)
{
u16 count, noOfDigits;
CsrUtf16String *output;
- CsrUint32 tempNumber;
+ u32 tempNumber;
/* calculate the number of digits in the output */
tempNumber = number;
* Output: 32 bit number.
*
*********************************************************************************/
-CsrUint32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString)
+u32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString)
{
u16 numLen, count;
- CsrUint32 newNumber = 0;
+ u32 newNumber = 0;
numLen = (u16) CsrUtf16StrLen(unicodeString);
* Output: A pointer to an unicoded string.
*
*********************************************************************************/
-CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, CsrUint32 count)
+CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, u32 count)
{
return CsrMemCpy((u8 *) dest, (u8 *) src, count * sizeof(CsrUtf16String));
}
const CsrUtf16String *inputText3, const CsrUtf16String *inputText4)
{
CsrUtf16String *outputText;
- CsrUint32 textLen, textLen1, textLen2, textLen3, textLen4;
+ u32 textLen, textLen1, textLen2, textLen3, textLen4;
textLen1 = CsrUtf16StrLen(inputText1);
textLen2 = CsrUtf16StrLen(inputText2);
* Output: The number of 16 bit elements in the string.
*
*********************************************************************************/
-CsrUint32 CsrUtf16StrLen(const CsrUtf16String *unicodeString)
+u32 CsrUtf16StrLen(const CsrUtf16String *unicodeString)
{
- CsrUint32 length;
+ u32 length;
length = 0;
if (unicodeString != NULL)
CsrUtf8String *CsrUtf16String2Utf8(const CsrUtf16String *source)
{
CsrUtf8String *dest, *destStart = NULL;
- CsrUint32 i;
- CsrUint32 ch;
- CsrUint32 length;
- CsrUint32 sourceLength;
+ u32 i;
+ u32 ch;
+ u32 length;
+ u32 sourceLength;
u8 bytes;
CsrBool appendNull = FALSE;
{
if (i + 1 < sourceLength) /* The low surrogate is in the source */
{
- CsrUint32 ch2 = source[++i];
+ u32 ch2 = source[++i];
if ((ch2 >= UNI_SUR_LOW_START) && (ch2 <= UNI_SUR_LOW_END)) /* And it is a legal low surrogate */
{
length += 4;
{
if (i + 1 < sourceLength) /* The low surrogate is in the source */
{
- CsrUint32 ch2 = source[++i];
+ u32 ch2 = source[++i];
if ((ch2 >= UNI_SUR_LOW_START) && (ch2 <= UNI_SUR_LOW_END)) /* And it is a legal low surrogate, convert to UTF-32 */
{
ch = ((ch - UNI_SUR_HIGH_START) << UNI_HALF_SHIFT) + (ch2 - UNI_SUR_LOW_START) + UNI_HALF_BASE;
}
/* Figure out how many bytes that are required */
- if (ch < (CsrUint32) 0x80)
+ if (ch < (u32) 0x80)
{
bytes = 1;
}
- else if (ch < (CsrUint32) 0x800)
+ else if (ch < (u32) 0x800)
{
bytes = 2;
}
- else if (ch < (CsrUint32) 0x10000)
+ else if (ch < (u32) 0x10000)
{
bytes = 3;
}
- else if (ch < (CsrUint32) 0x110000)
+ else if (ch < (u32) 0x110000)
{
bytes = 4;
}
TRUE if the given code unit is legal.
*****************************************************************************/
-static CsrBool isLegalUtf8(const CsrUtf8String *codeUnit, CsrUint32 length)
+static CsrBool isLegalUtf8(const CsrUtf8String *codeUnit, u32 length)
{
const CsrUtf8String *srcPtr = codeUnit + length;
u8 byte;
{
*dest++ = UNI_REPLACEMENT_CHAR;
}
- else /* It is legal, convert the character to an CsrUint32 */
+ else /* It is legal, convert the character to an u32 */
{
- CsrUint32 ch = 0;
+ u32 ch = 0;
switch (extraBytes2Read) /* Everything falls through */
{
CsrUtf16String *CsrUtf16StringDuplicate(const CsrUtf16String *source)
{
CsrUtf16String *target = NULL;
- CsrUint32 length;
+ u32 length;
if (source) /* if source is not NULL*/
{
* Output: 0: if the strings are identical.
*
*********************************************************************************/
-u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count)
+u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, u32 count)
{
while ((*string1 || *string2) && count--)
{
CsrUtf16String *scanString;
CsrUtf16String *outputString = NULL;
CsrUtf16String *resultString = str;
- CsrUint32 stringLength = 0;
+ u32 stringLength = 0;
CsrBool encodeChars = FALSE;
scanString = str;
CsrUtf16String *scanString;
CsrUtf16String *outputString = NULL;
CsrUtf16String *resultString = str;
- CsrUint32 stringLength = 0;
+ u32 stringLength = 0;
CsrBool encodeChars = FALSE;
scanString = str;
return CsrStrNCmp((const CsrCharString *) string1, (const CsrCharString *) string2, count);
}
-CsrUint32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string)
+u32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string)
{
CsrSize length = 0;
if (string)
{
length = CsrStrLen((const CsrCharString *) string);
}
- return (CsrUint32) length;
+ return (u32) length;
}
CsrUtf8String *CsrUtf8StrCpy(CsrUtf8String *target, const CsrUtf8String *source)
CsrUtf8String *CsrUtf8StringConcatenateTexts(const CsrUtf8String *inputText1, const CsrUtf8String *inputText2, const CsrUtf8String *inputText3, const CsrUtf8String *inputText4)
{
CsrUtf8String *outputText;
- CsrUint32 textLen, textLen1, textLen2, textLen3, textLen4;
+ u32 textLen, textLen1, textLen2, textLen3, textLen4;
textLen1 = CsrUtf8StringLengthInBytes(inputText1);
textLen2 = CsrUtf8StringLengthInBytes(inputText2);
/*------------------------------------------------------------------*/
/* Time proportional with the number of 1's */
-u8 CsrBitCountSparse(CsrUint32 n)
+u8 CsrBitCountSparse(u32 n)
{
u8 count = 0;
}
/* Time proportional with the number of 0's */
-u8 CsrBitCountDense(CsrUint32 n)
+u8 CsrBitCountDense(u32 n)
{
- u8 count = 8 * sizeof(CsrUint32);
+ u8 count = 8 * sizeof(u32);
- n ^= (CsrUint32) (-1);
+ n ^= (u32) (-1);
while (n)
{
return FALSE;
}
-CsrBool CsrHexStrToUint32(const CsrCharString *string, CsrUint32 *returnValue)
+CsrBool CsrHexStrToUint32(const CsrCharString *string, u32 *returnValue)
{
u16 currentIndex = 0;
*returnValue = 0;
return FALSE;
}
-CsrUint32 CsrPow(CsrUint32 base, CsrUint32 exponent)
+u32 CsrPow(u32 base, u32 exponent)
{
if (exponent == 0)
{
}
else
{
- CsrUint32 i, t = base;
+ u32 i, t = base;
for (i = 1; i < exponent; i++)
{
str[4] = '\0';
}
-void CsrUInt32ToHex(CsrUint32 number, CsrCharString *str)
+void CsrUInt32ToHex(u32 number, CsrCharString *str)
{
u16 index;
- CsrUint32 currentValue;
+ u32 currentValue;
for (index = 0; index < 8; index++)
{
- currentValue = (CsrUint32) (number & 0x0000000F);
+ currentValue = (u32) (number & 0x0000000F);
number >>= 4;
str[7 - index] = (char) (currentValue > 9 ? currentValue + 55 : currentValue + '0');
}
}
/* Convert string with base 10 to integer */
-CsrUint32 CsrStrToInt(const CsrCharString *str)
+u32 CsrStrToInt(const CsrCharString *str)
{
s16 i;
- CsrUint32 res;
- CsrUint32 digit;
+ u32 res;
+ u32 digit;
res = 0;
digit = 1;
CsrCharString *CsrStrDup(const CsrCharString *string)
{
CsrCharString *copy;
- CsrUint32 len;
+ u32 len;
copy = NULL;
if (string != NULL)
const CsrCharString *string2,
CsrSize count)
{
- CsrUint32 index;
+ u32 index;
int returnValue = 0;
for (index = 0; index < count; index++)
#include "csr_macro.h"
/*------------------------------------------------------------------*/
-/* Bits - intended to operate on CsrUint32 values */
+/* Bits - intended to operate on u32 values */
/*------------------------------------------------------------------*/
-u8 CsrBitCountSparse(CsrUint32 n);
-u8 CsrBitCountDense(CsrUint32 n);
+u8 CsrBitCountSparse(u32 n);
+u8 CsrBitCountDense(u32 n);
/*------------------------------------------------------------------*/
/* Base conversion */
/*------------------------------------------------------------------*/
CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue);
CsrBool CsrHexStrToUint16(const CsrCharString *string, u16 *returnValue);
-CsrBool CsrHexStrToUint32(const CsrCharString *string, CsrUint32 *returnValue);
-CsrUint32 CsrPow(CsrUint32 base, CsrUint32 exponent);
+CsrBool CsrHexStrToUint32(const CsrCharString *string, u32 *returnValue);
+u32 CsrPow(u32 base, u32 exponent);
void CsrIntToBase10(CsrInt32 number, CsrCharString *str);
void CsrUInt16ToHex(u16 number, CsrCharString *str);
-void CsrUInt32ToHex(CsrUint32 number, CsrCharString *str);
+void CsrUInt32ToHex(u32 number, CsrCharString *str);
/*------------------------------------------------------------------*/
/* Standard C Library functions */
void *CsrMemDup(const void *buf1, CsrSize count);
int CsrStrNICmp(const CsrCharString *string1, const CsrCharString *string2, CsrSize count);
CsrCharString *CsrStrDup(const CsrCharString *string);
-CsrUint32 CsrStrToInt(const CsrCharString *string);
+u32 CsrStrToInt(const CsrCharString *string);
CsrCharString *CsrStrNCpyZero(CsrCharString *dest, const CsrCharString *src, CsrSize count);
/*------------------------------------------------------------------*/
* @param[in] context : FSM context
*
* @return
- * CsrUint32 Time in ms until next timeout or 0xFFFFFFFF for no timer set
+ * u32 Time in ms until next timeout or 0xFFFFFFFF for no timer set
*/
-extern CsrUint32 CsrWifiFsmExecute(CsrWifiFsmContext *context);
+extern u32 CsrWifiFsmExecute(CsrWifiFsmContext *context);
/**
* @brief
* @param[in] context : FSM context
*
* @return
- * CsrUint32 32 bit ms tick
+ * u32 32 bit ms tick
*/
-extern CsrUint32 CsrWifiFsmGetTimeOfDayMs(CsrWifiFsmContext *context);
+extern u32 CsrWifiFsmGetTimeOfDayMs(CsrWifiFsmContext *context);
/**
* @brief
* @param[in] context : FSM context
*
* @return
- * CsrUint32 Time in ms until next timeout or 0xFFFFFFFF for no timer set
+ * u32 Time in ms until next timeout or 0xFFFFFFFF for no timer set
*/
-extern CsrUint32 CsrWifiFsmGetNextTimeout(CsrWifiFsmContext *context);
+extern u32 CsrWifiFsmGetNextTimeout(CsrWifiFsmContext *context);
/**
* @brief
* @return
* void
*/
-extern void CsrWifiFsmTestAdvanceTime(CsrWifiFsmContext *context, CsrUint32 ms);
+extern void CsrWifiFsmTestAdvanceTime(CsrWifiFsmContext *context, u32 ms);
/**
* @brief
struct CsrWifiFsmTimer *next;
CsrWifiFsmTimerId timerid;
- CsrUint32 timeoutTimeMs;
+ u32 timeoutTimeMs;
} CsrWifiFsmTimer;
*/
typedef struct
{
- CsrUint32 eventid;
+ u32 eventid;
CsrWifiFsmTransitionFnPtr transition;
#ifdef CSR_LOG_ENABLE
const CsrCharString *transitionName;
typedef struct
{
const CsrCharString *processName;
- const CsrUint32 processId;
+ const u32 processId;
const CsrWifiFsmTransitionFunctionTable transitionTable;
const CsrWifiFsmTableEntry unhandledTransitions;
const CsrWifiFsmTableEntry ignoreFunctions;
#ifdef CSR_WIFI_FSM_MUTEX_ENABLE
CsrMutexHandle externalEventQueueLock; /* The external event queue mutex */
#endif
- CsrUint32 timeOffset; /* Amount to adjust the TimeOfDayMs by */
+ u32 timeOffset; /* Amount to adjust the TimeOfDayMs by */
CsrWifiFsmTimerList timerQueue; /* The internal timer queue */
CsrBool useTempSaveList; /* Should the temp save list be used */
CsrWifiFsmEventList tempSaveList; /* The temp save event queue */
#ifndef CSR_WIFI_FSM_SCHEDULER_DISABLED
CsrSchedTid schedTimerId; /* Scheduler TimerId for use in Scheduler Tasks */
- CsrUint32 schedTimerNexttimeoutMs; /* Next timeout time for the current timer */
+ u32 schedTimerNexttimeoutMs; /* Next timeout time for the current timer */
#endif
#ifdef CSR_WIFI_FSM_MUTEX_ENABLE
CsrResult card_start_processor(card_t *card, enum unifi_dbg_processors_select which);
-CsrResult card_wait_for_firmware_to_start(card_t *card, CsrUint32 *paddr);
+CsrResult card_wait_for_firmware_to_start(card_t *card, u32 *paddr);
CsrResult unifi_dl_firmware(card_t *card, void *arg);
-CsrResult unifi_dl_patch(card_t *card, void *arg, CsrUint32 boot_ctrl);
-CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, u8 opcode);
+CsrResult unifi_dl_patch(card_t *card, void *arg, u32 boot_ctrl);
+CsrResult unifi_do_loader_op(card_t *card, u32 op_addr, u8 opcode);
void* unifi_dl_fw_read_start(card_t *card, s8 is_fw);
CsrResult unifi_coredump_handle_request(card_t *card);
card_t* unifi_alloc_card(CsrSdioFunction *sdio, void *ospriv)
{
card_t *card;
- CsrUint32 i;
+ u32 i;
func_enter();
card->unifi_interrupt_seq = 1;
/* Make these invalid. */
- card->proc_select = (CsrUint32)(-1);
- card->dmem_page = (CsrUint32)(-1);
- card->pmem_page = (CsrUint32)(-1);
+ card->proc_select = (u32)(-1);
+ card->dmem_page = (u32)(-1);
+ card->pmem_page = (u32)(-1);
card->bh_reason_host = 0;
card->bh_reason_unifi = 0;
* warnings when casting pointer types, e.g. on 64-bit systems.
*/
{
- CsrUint32 val = 0x01234567;
+ u32 val = 0x01234567;
if (*((u8 *)&val) == 0x01)
{
* The page registers will be maintained by unifi_read...() and
* unifi_write...().
*/
- card->proc_select = (CsrUint32)(-1);
- card->dmem_page = (CsrUint32)(-1);
- card->pmem_page = (CsrUint32)(-1);
+ card->proc_select = (u32)(-1);
+ card->dmem_page = (u32)(-1);
+ card->pmem_page = (u32)(-1);
r = unifi_write_direct16(card, ChipHelper_HOST_WINDOW3_PAGE(card->helper) * 2, 0);
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
{
*/
static CsrResult card_hw_init(card_t *card)
{
- CsrUint32 slut_address;
+ u32 slut_address;
u16 initialised;
u16 finger_print;
symbol_t slut;
while (!search_4slut_again)
{
u16 s;
- CsrUint32 l;
+ u32 l;
r = unifi_card_read16(card, slut_address, &s);
if (r != CSR_RESULT_SUCCESS)
case CSR_SLT_BUILD_ID_NUMBER:
{
- CsrUint32 n;
+ u32 n;
r = unifi_read32(card, slut.obj, &n);
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
{
* CSR_RESULT_SUCCESS on success, CSR error code on failure.
* ---------------------------------------------------------------------------
*/
-CsrResult card_wait_for_firmware_to_start(card_t *card, CsrUint32 *paddr)
+CsrResult card_wait_for_firmware_to_start(card_t *card, u32 *paddr)
{
CsrInt32 i;
u16 mbox0, mbox1;
return r;
}
- *paddr = (((CsrUint32)mbox1 << 16) | mbox0);
+ *paddr = (((u32)mbox1 << 16) | mbox0);
func_exit();
return CSR_RESULT_SUCCESS;
/* Allocate memory for the array used for slot host tag mapping */
card->fh_slot_host_tag_record =
- (CsrUint32 *)CsrMemAlloc(n * sizeof(CsrUint32));
+ (u32 *)CsrMemAlloc(n * sizeof(u32));
if (card->fh_slot_host_tag_record == NULL)
{
static CsrResult unifi_read_chip_version(card_t *card)
{
- CsrUint32 gbl_chip_version;
+ u32 gbl_chip_version;
CsrResult r;
u16 ver;
{
CsrResult r;
const struct chip_helper_reset_values *init_data;
- CsrUint32 chunks;
+ u32 chunks;
func_enter();
/* Clear cache of page registers */
- card->proc_select = (CsrUint32)(-1);
- card->dmem_page = (CsrUint32)(-1);
- card->pmem_page = (CsrUint32)(-1);
+ card->proc_select = (u32)(-1);
+ card->dmem_page = (u32)(-1);
+ card->pmem_page = (u32)(-1);
/*
* We need to have a valid card->helper before we use software hard reset.
static void bootstrap_chip_hw(card_t *card)
{
const struct chip_helper_init_values *vals;
- CsrUint32 i, len;
+ u32 i, len;
void *sdio = card->sdio_if;
CsrResult csrResult;
* None
* ---------------------------------------------------------------------------
*/
-void unifi_set_interrupt_mode(card_t *card, CsrUint32 mode)
+void unifi_set_interrupt_mode(card_t *card, u32 mode)
{
if (mode == CSR_WIFI_INTMODE_RUN_BH_ONCE)
{
{
CsrInt32 count_fhr;
s16 t;
- CsrUint32 occupied_fh;
+ u32 occupied_fh;
q_t *sigq;
u16 nslots, i;
u16 initialised;
/* Added by protocol version 0x0001 */
- CsrUint32 overlay_size;
+ u32 overlay_size;
/* Added by protocol version 0x0300 */
u16 data_slot_round;
* array is indexed by slot numbers and each index stores
* information of the last host tag it was used for
*/
- CsrUint32 *fh_slot_host_tag_record;
+ u32 *fh_slot_host_tag_record;
/* Info read from Symbol Table during probe */
- CsrUint32 build_id;
+ u32 build_id;
CsrCharString build_id_string[128];
/* Retrieve from SDIO driver. */
u8 request_max_clock;
/* Last SDIO clock frequency set */
- CsrUint32 sdio_clock_speed;
+ u32 sdio_clock_speed;
/*
* Current host state (copy of value in IOABORT register and
* SHARED_IO_INTERRUPT register.
* Flag to say we need to generate an interrupt at end of processing.
*/
- CsrUint32 unifi_interrupt_seq;
+ u32 unifi_interrupt_seq;
u8 generate_interrupt;
sdio_config_data_t config_data;
/* SDIO address of the Initialised flag and Control Data struct */
- CsrUint32 init_flag_addr;
- CsrUint32 sdio_ctrl_addr;
+ u32 init_flag_addr;
+ u32 sdio_ctrl_addr;
/* The last value written to the Shared Data Memory Page register */
- CsrUint32 proc_select;
- CsrUint32 dmem_page;
- CsrUint32 pmem_page;
+ u32 proc_select;
+ u32 dmem_page;
+ u32 pmem_page;
/* SDIO traffic counters limited to 32 bits for Synergy compatibility */
- CsrUint32 sdio_bytes_read;
- CsrUint32 sdio_bytes_written;
+ u32 sdio_bytes_read;
+ u32 sdio_bytes_written;
u8 memory_resources_allocated;
#ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
struct cmd_profile
{
- CsrUint32 cmd52_count;
- CsrUint32 cmd53_count;
- CsrUint32 tx_count;
- CsrUint32 tx_cfm_count;
- CsrUint32 rx_count;
- CsrUint32 bh_count;
- CsrUint32 process_count;
- CsrUint32 protocol_count;
-
- CsrUint32 cmd52_f0_r_count;
- CsrUint32 cmd52_f0_w_count;
- CsrUint32 cmd52_r8or16_count;
- CsrUint32 cmd52_w8or16_count;
- CsrUint32 cmd52_r16_count;
- CsrUint32 cmd52_w16_count;
- CsrUint32 cmd52_r32_count;
-
- CsrUint32 sdio_cmd_signal;
- CsrUint32 sdio_cmd_clear_slot;
- CsrUint32 sdio_cmd_to_host;
- CsrUint32 sdio_cmd_from_host;
- CsrUint32 sdio_cmd_from_host_and_clear;
+ u32 cmd52_count;
+ u32 cmd53_count;
+ u32 tx_count;
+ u32 tx_cfm_count;
+ u32 rx_count;
+ u32 bh_count;
+ u32 process_count;
+ u32 protocol_count;
+
+ u32 cmd52_f0_r_count;
+ u32 cmd52_f0_w_count;
+ u32 cmd52_r8or16_count;
+ u32 cmd52_w8or16_count;
+ u32 cmd52_r16_count;
+ u32 cmd52_w16_count;
+ u32 cmd52_r32_count;
+
+ u32 sdio_cmd_signal;
+ u32 sdio_cmd_clear_slot;
+ u32 sdio_cmd_to_host;
+ u32 sdio_cmd_from_host;
+ u32 sdio_cmd_from_host_and_clear;
} hip_prof;
struct cmd_profile cmd_prof;
#endif
/* Interrupt processing mode flags */
- CsrUint32 intmode;
+ u32 intmode;
#ifdef UNIFI_DEBUG
u8 lsb;
#endif
/* Historic firmware panic codes */
- CsrUint32 panic_data_phy_addr;
- CsrUint32 panic_data_mac_addr;
+ u32 panic_data_phy_addr;
+ u32 panic_data_mac_addr;
u16 last_phy_panic_code;
u16 last_phy_panic_arg;
u16 last_mac_panic_code;
bulk_data_desc_t* card_find_data_slot(card_t *card, s16 slot);
-CsrResult unifi_read32(card_t *card, CsrUint32 unifi_addr, CsrUint32 *pdata);
-CsrResult unifi_readnz(card_t *card, CsrUint32 unifi_addr,
+CsrResult unifi_read32(card_t *card, u32 unifi_addr, u32 *pdata);
+CsrResult unifi_readnz(card_t *card, u32 unifi_addr,
void *pdata, u16 len);
-CsrInt32 unifi_read_shared_count(card_t *card, CsrUint32 addr);
+CsrInt32 unifi_read_shared_count(card_t *card, u32 addr);
-CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len);
+CsrResult unifi_writen(card_t *card, u32 unifi_addr, void *pdata, u16 len);
-CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle,
- void *pdata, CsrUint32 len, s16 direction);
-CsrResult unifi_bulk_rw_noretry(card_t *card, CsrUint32 handle,
- void *pdata, CsrUint32 len, s16 direction);
+CsrResult unifi_bulk_rw(card_t *card, u32 handle,
+ void *pdata, u32 len, s16 direction);
+CsrResult unifi_bulk_rw_noretry(card_t *card, u32 handle,
+ void *pdata, u32 len, s16 direction);
#define UNIFI_SDIO_READ 0
#define UNIFI_SDIO_WRITE 1
-CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 *pdata);
-CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 data);
-CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, u8 *pdata);
-CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, u8 data);
+CsrResult unifi_read_8_or_16(card_t *card, u32 unifi_addr, u8 *pdata);
+CsrResult unifi_write_8_or_16(card_t *card, u32 unifi_addr, u8 data);
+CsrResult unifi_read_direct_8_or_16(card_t *card, u32 addr, u8 *pdata);
+CsrResult unifi_write_direct_8_or_16(card_t *card, u32 addr, u8 data);
-CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, u16 *pdata);
-CsrResult unifi_read_direct32(card_t *card, CsrUint32 addr, CsrUint32 *pdata);
-CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len);
+CsrResult unifi_read_direct16(card_t *card, u32 addr, u16 *pdata);
+CsrResult unifi_read_direct32(card_t *card, u32 addr, u32 *pdata);
+CsrResult unifi_read_directn(card_t *card, u32 addr, void *pdata, u16 len);
-CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, u16 data);
-CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len);
+CsrResult unifi_write_direct16(card_t *card, u32 addr, u16 data);
+CsrResult unifi_write_directn(card_t *card, u32 addr, void *pdata, u16 len);
-CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, u8 *pdata);
-CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, u8 data);
+CsrResult sdio_read_f0(card_t *card, u32 addr, u8 *pdata);
+CsrResult sdio_write_f0(card_t *card, u32 addr, u8 data);
void unifi_read_panic(card_t *card);
#ifdef CSR_PRE_ALLOC_NET_DATA
}
-static CsrResult prealloc_netdata_get(card_t *card, bulk_data_desc_t *bulk_data_slot, CsrUint32 size)
+static CsrResult prealloc_netdata_get(card_t *card, bulk_data_desc_t *bulk_data_slot, u32 size)
{
CsrResult r;
* CSR_RESULT_SUCCESS on success or a CSR error code.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_bh(card_t *card, CsrUint32 *remaining)
+CsrResult unifi_bh(card_t *card, u32 *remaining)
{
CsrResult r;
CsrResult csrResult;
if (GET_SIGNAL_ID(bufptr + 2) == CSR_MA_PACKET_CONFIRM_ID)
{
/* Get host tag and transmission status */
- CsrUint32 host_tag = GET_PACKED_MA_PACKET_CONFIRM_HOST_TAG(bufptr + 2);
+ u32 host_tag = GET_PACKED_MA_PACKET_CONFIRM_HOST_TAG(bufptr + 2);
u16 status = GET_PACKED_MA_PACKET_CONFIRM_TRANSMISSION_STATUS(bufptr + 2);
unifi_trace(card->ospriv, UDBG4, "process_to_host_signals signal ID=%x host Tag=%x status=%x\n",
*/
static CsrResult check_fh_sig_slots(card_t *card, u16 needed, CsrInt32 *space_fh)
{
- CsrUint32 count_fhw;
- CsrUint32 occupied_fh, slots_fh;
+ u32 count_fhw;
+ u32 occupied_fh, slots_fh;
CsrInt32 count_fhr;
count_fhw = card->from_host_signals_w;
u16 needed_chunks;
CsrInt32 space_chunks;
u16 q_index;
- CsrUint32 host_tag = 0;
+ u32 host_tag = 0;
u16 slot_num = 0;
*processed = 0;
* CSR_RESULT_FAILURE an SDIO error occurred
* ---------------------------------------------------------------------------
*/
-static CsrResult retrying_read8(card_t *card, s16 funcnum, CsrUint32 addr, u8 *pdata)
+static CsrResult retrying_read8(card_t *card, s16 funcnum, u32 addr, u8 *pdata)
{
CsrSdioFunction *sdio = card->sdio_if;
CsrResult r = CSR_RESULT_SUCCESS;
} /* retrying_read8() */
-static CsrResult retrying_write8(card_t *card, s16 funcnum, CsrUint32 addr, u8 data)
+static CsrResult retrying_write8(card_t *card, s16 funcnum, u32 addr, u8 data)
{
CsrSdioFunction *sdio = card->sdio_if;
CsrResult r = CSR_RESULT_SUCCESS;
static CsrResult retrying_read16(card_t *card, s16 funcnum,
- CsrUint32 addr, u16 *pdata)
+ u32 addr, u16 *pdata)
{
CsrSdioFunction *sdio = card->sdio_if;
CsrResult r = CSR_RESULT_SUCCESS;
static CsrResult retrying_write16(card_t *card, s16 funcnum,
- CsrUint32 addr, u16 data)
+ u32 addr, u16 data)
{
CsrSdioFunction *sdio = card->sdio_if;
CsrResult r = CSR_RESULT_SUCCESS;
* CSR_RESULT_FAILURE an SDIO error occurred
* ---------------------------------------------------------------------------
*/
-CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, u8 *pdata)
+CsrResult sdio_read_f0(card_t *card, u32 addr, u8 *pdata)
{
#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
card->cmd_prof.cmd52_f0_r_count++;
* CSR_RESULT_FAILURE an SDIO error occurred
* ---------------------------------------------------------------------------
*/
-CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, u8 data)
+CsrResult sdio_write_f0(card_t *card, u32 addr, u8 data)
{
#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
card->cmd_prof.cmd52_f0_w_count++;
* CSR_RESULT_SUCCESS on success, non-zero error code on error:
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, u8 *pdata)
+CsrResult unifi_read_direct_8_or_16(card_t *card, u32 addr, u8 *pdata)
{
#ifdef CSR_WIFI_TRANSPORT_CSPI
u16 w;
* to memory until the preceding even address is written.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, u8 data)
+CsrResult unifi_write_direct_8_or_16(card_t *card, u32 addr, u8 data)
{
if (addr & 1)
{
* even address is read.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, u16 *pdata)
+CsrResult unifi_read_direct16(card_t *card, u32 addr, u16 *pdata)
{
return retrying_read16(card, card->function, addr, pdata);
} /* unifi_read_direct16() */
* even address is written.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, u16 data)
+CsrResult unifi_write_direct16(card_t *card, u32 addr, u16 data)
{
return retrying_write16(card, card->function, addr, data);
} /* unifi_write_direct16() */
* CSR_RESULT_FAILURE an SDIO error occurred
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_read_direct32(card_t *card, CsrUint32 addr, CsrUint32 *pdata)
+CsrResult unifi_read_direct32(card_t *card, u32 addr, u32 *pdata)
{
CsrResult r;
u16 w0, w1;
return r;
}
- *pdata = ((CsrUint32)w1 << 16) | (CsrUint32)w0;
+ *pdata = ((u32)w1 << 16) | (u32)w0;
return CSR_RESULT_SUCCESS;
} /* unifi_read_direct32() */
* even address is read.
* ---------------------------------------------------------------------------
*/
-static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pdata, u16 len, s8 m, CsrUint32 *num)
+static CsrResult unifi_read_directn_match(card_t *card, u32 addr, void *pdata, u16 len, s8 m, u32 *num)
{
CsrResult r;
- CsrUint32 i;
+ u32 i;
u8 *cptr;
u16 w;
* even address is read.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len)
+CsrResult unifi_read_directn(card_t *card, u32 addr, void *pdata, u16 len)
{
- CsrUint32 num;
+ u32 num;
return unifi_read_directn_match(card, addr, pdata, len, -1, &num);
} /* unifi_read_directn() */
* This means we must write data as pairs of bytes in reverse order.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len)
+CsrResult unifi_write_directn(card_t *card, u32 addr, void *pdata, u16 len)
{
CsrResult r;
u8 *cptr;
* CSR_RESULT_FAILURE an SDIO error occurred
* ---------------------------------------------------------------------------
*/
-static CsrResult set_dmem_page(card_t *card, CsrUint32 dmem_addr, CsrUint32 *paddr)
+static CsrResult set_dmem_page(card_t *card, u32 dmem_addr, u32 *paddr)
{
u16 page, addr;
- CsrUint32 len;
+ u32 len;
CsrResult r;
*paddr = 0;
} /* set_dmem_page() */
-static CsrResult set_pmem_page(card_t *card, CsrUint32 pmem_addr,
- enum chip_helper_window_type mem_type, CsrUint32 *paddr)
+static CsrResult set_pmem_page(card_t *card, u32 pmem_addr,
+ enum chip_helper_window_type mem_type, u32 *paddr)
{
u16 page, addr;
- CsrUint32 len;
+ u32 len;
CsrResult r;
*paddr = 0;
* CSR_WIFI_HIP_RESULT_INVALID_VALUE the address is invalid
* ---------------------------------------------------------------------------
*/
-static CsrResult set_page(card_t *card, CsrUint32 generic_addr, CsrUint32 *paddr)
+static CsrResult set_page(card_t *card, u32 generic_addr, u32 *paddr)
{
CsrInt32 space;
- CsrUint32 addr;
+ u32 addr;
CsrResult r = CSR_RESULT_SUCCESS;
if (!paddr)
return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
}
- if (card->proc_select != (CsrUint32)select)
+ if (card->proc_select != (u32)select)
{
r = unifi_write_direct16(card,
ChipHelper_DBG_HOST_PROC_SELECT(card->helper) * 2,
return r;
}
- card->proc_select = (CsrUint32)select;
+ card->proc_select = (u32)select;
}
return CSR_RESULT_SUCCESS;
* CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 *pdata)
+CsrResult unifi_read_8_or_16(card_t *card, u32 unifi_addr, u8 *pdata)
{
- CsrUint32 sdio_addr;
+ u32 sdio_addr;
CsrResult r;
#ifdef CSR_WIFI_TRANSPORT_CSPI
u16 w;
* write with the previously cached odd byte.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 data)
+CsrResult unifi_write_8_or_16(card_t *card, u32 unifi_addr, u8 data)
{
- CsrUint32 sdio_addr;
+ u32 sdio_addr;
CsrResult r;
#ifdef CSR_WIFI_TRANSPORT_CSPI
u16 w;
* CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, u16 *pdata)
+CsrResult unifi_card_read16(card_t *card, u32 unifi_addr, u16 *pdata)
{
- CsrUint32 sdio_addr;
+ u32 sdio_addr;
CsrResult r;
r = set_page(card, unifi_addr, &sdio_addr);
* CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, u16 data)
+CsrResult unifi_card_write16(card_t *card, u32 unifi_addr, u16 data)
{
- CsrUint32 sdio_addr;
+ u32 sdio_addr;
CsrResult r;
r = set_page(card, unifi_addr, &sdio_addr);
* CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_read32(card_t *card, CsrUint32 unifi_addr, CsrUint32 *pdata)
+CsrResult unifi_read32(card_t *card, u32 unifi_addr, u32 *pdata)
{
- CsrUint32 sdio_addr;
+ u32 sdio_addr;
CsrResult r;
r = set_page(card, unifi_addr, &sdio_addr);
* CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_readn_match(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len, s8 match)
+CsrResult unifi_readn_match(card_t *card, u32 unifi_addr, void *pdata, u16 len, s8 match)
{
- CsrUint32 sdio_addr;
+ u32 sdio_addr;
CsrResult r;
- CsrUint32 num;
+ u32 num;
r = set_page(card, unifi_addr, &sdio_addr);
if (r != CSR_RESULT_SUCCESS)
} /* unifi_readn_match() */
-CsrResult unifi_card_readn(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len)
+CsrResult unifi_card_readn(card_t *card, u32 unifi_addr, void *pdata, u16 len)
{
return unifi_readn_match(card, unifi_addr, pdata, len, -1);
} /* unifi_card_readn() */
-CsrResult unifi_readnz(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len)
+CsrResult unifi_readnz(card_t *card, u32 unifi_addr, void *pdata, u16 len)
{
return unifi_readn_match(card, unifi_addr, pdata, len, 0);
} /* unifi_readnz() */
* Value read from memory (0-127) or -1 on error
* ---------------------------------------------------------------------------
*/
-CsrInt32 unifi_read_shared_count(card_t *card, CsrUint32 addr)
+CsrInt32 unifi_read_shared_count(card_t *card, u32 addr)
{
u8 b;
/* I've increased this count, because I have seen cases where
* CSR_WIFI_HIP_RESULT_INVALID_VALUE an odd length or length too big.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len)
+CsrResult unifi_writen(card_t *card, u32 unifi_addr, void *pdata, u16 len)
{
- CsrUint32 sdio_addr;
+ u32 sdio_addr;
CsrResult r;
r = set_page(card, unifi_addr, &sdio_addr);
static CsrResult csr_sdio_block_rw(card_t *card, s16 funcnum,
- CsrUint32 addr, u8 *pdata,
+ u32 addr, u8 *pdata,
u16 count, s16 dir_is_write)
{
CsrResult csrResult;
* This function uses SDIO CMD53, which is the block transfer mode.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle, void *pdata,
- CsrUint32 len, s16 direction)
+CsrResult unifi_bulk_rw(card_t *card, u32 handle, void *pdata,
+ u32 len, s16 direction)
{
#define CMD53_RETRIES 3
/*
* This function uses SDIO CMD53, which is the block transfer mode.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_bulk_rw_noretry(card_t *card, CsrUint32 handle, void *pdata,
- CsrUint32 len, s16 direction)
+CsrResult unifi_bulk_rw_noretry(card_t *card, u32 handle, void *pdata,
+ u32 len, s16 direction)
{
CsrResult csrResult;
ChipDescript* ChipHelper_GetVersionSdio(u8 sdio_ver)
{
- CsrUint32 i;
+ u32 i;
for (i = 0; i < nelem(chip_ver_to_desc); i++)
{
ChipDescript* ChipHelper_GetVersionAny(u16 from_FF9A, u16 from_FE81)
{
- CsrUint32 i;
+ u32 i;
if ((from_FF9A & 0xFF00) != 0)
{
*/
u16 ChipHelper_MapAddress_SPI2HOST(ChipDescript *chip_help, u16 addr)
{
- CsrUint32 i;
+ u32 i;
for (i = 0; i < chip_help->map.len; i++)
{
if (chip_help->map.vals[i].spi == addr)
u16 ChipHelper_MapAddress_HOST2SPI(ChipDescript *chip_help, u16 addr)
{
- CsrUint32 i;
+ u32 i;
for (i = 0; i < chip_help->map.len; i++)
{
if (chip_help->map.vals[i].host == addr)
/* Get the register writes we should do to make sure that
the chip is running with most clocks on. */
-CsrUint32 ChipHelper_ClockStartupSequence(ChipDescript *chip_help,
+u32 ChipHelper_ClockStartupSequence(ChipDescript *chip_help,
const struct chip_helper_init_values **val)
{
*val = chip_help->init.vals;
/* Get the set of values tat we should write to the chip to perform a reset. */
-CsrUint32 ChipHelper_HostResetSequence(ChipDescript *chip_help,
+u32 ChipHelper_HostResetSequence(ChipDescript *chip_help,
const struct chip_helper_reset_values **val)
{
*val = chip_help->reset_prog.vals;
CsrInt32 ChipHelper_DecodeWindow(ChipDescript *chip_help,
enum chip_helper_window_index window,
enum chip_helper_window_type type,
- CsrUint32 offset,
- u16 *page, u16 *addr, CsrUint32 *len)
+ u32 offset,
+ u16 *page, u16 *addr, u32 *len)
{
const struct window_info_t *win;
const struct window_shift_info_t *mode;
/* A block of data that should be written to the device */
struct chip_helper_reset_values
{
- CsrUint32 gp_address;
- CsrUint32 len;
+ u32 gp_address;
+ u32 len;
const u16 *data;
};
CHIP_HELPER_DEF0(m, (u16, SDIO_HOST_INT, regs->sdio_host_int)) \
CHIP_HELPER_DEF0(m, (u16, COEX_STATUS, regs->coex_status)) \
CHIP_HELPER_DEF0(m, (u16, SHARED_IO_INTERRUPT, regs->shared_io_interrupt)) \
- CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_RAM_OFFSET, prog_offset.ram)) \
- CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_ROM_OFFSET, prog_offset.rom)) \
- CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_FLASH_OFFSET, prog_offset.flash)) \
- CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_EXT_SRAM_OFFSET, prog_offset.ext_sram)) \
+ CHIP_HELPER_DEF0(m, (u32, PROGRAM_MEMORY_RAM_OFFSET, prog_offset.ram)) \
+ CHIP_HELPER_DEF0(m, (u32, PROGRAM_MEMORY_ROM_OFFSET, prog_offset.rom)) \
+ CHIP_HELPER_DEF0(m, (u32, PROGRAM_MEMORY_FLASH_OFFSET, prog_offset.flash)) \
+ CHIP_HELPER_DEF0(m, (u32, PROGRAM_MEMORY_EXT_SRAM_OFFSET, prog_offset.ext_sram)) \
CHIP_HELPER_DEF0(m, (u16, DATA_MEMORY_RAM_OFFSET, data_offset.ram)) \
CHIP_HELPER_DEF0(m, (CsrInt32, HasFlash, bools.has_flash)) \
CHIP_HELPER_DEF0(m, (CsrInt32, HasExtSram, bools.has_ext_sram)) \
CHIP_HELPER_DEF1(m, (u16, WINDOW_SIZE, enum chip_helper_window_index, window)) \
CHIP_HELPER_DEF1(m, (u16, MapAddress_SPI2HOST, u16, addr)) \
CHIP_HELPER_DEF1(m, (u16, MapAddress_HOST2SPI, u16, addr)) \
- CHIP_HELPER_DEF1(m, (CsrUint32, ClockStartupSequence, const struct chip_helper_init_values **, val)) \
- CHIP_HELPER_DEF1(m, (CsrUint32, HostResetSequence, const struct chip_helper_reset_values **, val))
+ CHIP_HELPER_DEF1(m, (u32, ClockStartupSequence, const struct chip_helper_init_values **, val)) \
+ CHIP_HELPER_DEF1(m, (u32, HostResetSequence, const struct chip_helper_reset_values **, val))
/* Some magic to help the expansion */
#define CHIP_HELPER_DEF0(a, b) \
CsrInt32 ChipHelper_DecodeWindow(ChipDescript *chip_help,
enum chip_helper_window_index window,
enum chip_helper_window_type type,
- CsrUint32 offset,
- u16 *page, u16 *addr, CsrUint32 *len);
+ u32 offset,
+ u16 *page, u16 *addr, u32 *len);
#ifdef __cplusplus
/* Close the extern "C" */
/* The DecodeWindow function, see the description of the C version. */
CsrInt32 DecodeWindow(chip_helper_window_index window,
chip_helper_window_type type,
- CsrUint32 offset,
- u16 &page, u16 &addr, CsrUint32 &len) const;
+ u32 offset,
+ u16 &page, u16 &addr, u32 &len) const;
private:
ChipDescript *m_desc;
/* Address value pairs */
struct val_array_t
{
- CsrUint32 len;
+ u32 len;
const struct chip_helper_init_values *vals;
};
/* Just a (counted) u16 array */
struct data_array_t
{
- CsrUint32 len;
+ u32 len;
const u16 *vals;
};
struct reset_prog_t
{
- CsrUint32 len;
+ u32 len;
const struct chip_helper_reset_values *vals;
};
struct map_array_t
{
- CsrUint32 len;
+ u32 len;
const struct chip_map_address_t *vals;
};
struct window_shift_info_t
{
CsrInt32 allowed;
- CsrUint32 page_shift;
+ u32 page_shift;
u16 page_offset;
};
/* Some misc. info on the chip */
struct
{
- CsrUint32 has_flash : 1;
- CsrUint32 has_ext_sram : 1;
- CsrUint32 has_rom : 1;
- CsrUint32 has_bt : 1;
- CsrUint32 has_wlan : 1;
+ u32 has_flash : 1;
+ u32 has_ext_sram : 1;
+ u32 has_rom : 1;
+ u32 has_bt : 1;
+ u32 has_wlan : 1;
} bools;
/* This table is used to remap register addresses depending on what
The RAM offset is probably the most useful. */
struct
{
- CsrUint32 ram;
- CsrUint32 rom;
- CsrUint32 flash;
- CsrUint32 ext_sram;
+ u32 ram;
+ u32 rom;
+ u32 flash;
+ u32 ext_sram;
} prog_offset;
/* The offsets into the data address space of interesting things. */
#undef CSR_WIFI_IGNORE_PATCH_VERSION_MISMATCH
static CsrResult do_patch_download(card_t *card, void *dlpriv,
- xbv1_t *pfwinfo, CsrUint32 boot_ctrl_addr);
+ xbv1_t *pfwinfo, u32 boot_ctrl_addr);
static CsrResult do_patch_convert_download(card_t *card,
void *dlpriv, xbv1_t *pfwinfo);
* CSR_WIFI_HIP_RESULT_NOT_FOUND if not found
* ---------------------------------------------------------------------------
*/
-static CsrResult _find_in_slut(card_t *card, symbol_t *psym, CsrUint32 *pslut)
+static CsrResult _find_in_slut(card_t *card, symbol_t *psym, u32 *pslut)
{
- CsrUint32 slut_address;
+ u32 slut_address;
u16 finger_print;
CsrResult r;
CsrResult csrResult;
while (1)
{
u16 id;
- CsrUint32 obj;
+ u32 obj;
r = unifi_card_read16(card, slut_address, &id);
if (r != CSR_RESULT_SUCCESS)
static CsrResult do_patch_convert_download(card_t *card, void *dlpriv, xbv1_t *pfwinfo)
{
CsrResult r;
- CsrUint32 slut_base = 0xffffffff;
+ u32 slut_base = 0xffffffff;
void *pfw;
- CsrUint32 psize;
+ u32 psize;
symbol_t sym;
/* Reset the chip to guarantee that the ROM loader is running */
/* If no unifi_helper is running, the firmware version must be read */
if (card->build_id == 0)
{
- CsrUint32 ver = 0;
+ u32 ver = 0;
sym.id = CSR_SLT_BUILD_ID_NUMBER;
sym.obj = 0; /* To be updated by _find_in_slut() */
* This ends up telling UniFi to restart.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_dl_patch(card_t *card, void *dlpriv, CsrUint32 boot_ctrl)
+CsrResult unifi_dl_patch(card_t *card, void *dlpriv, u32 boot_ctrl)
{
xbv1_t *fwinfo;
CsrResult r;
* CSR_RESULT_SUCCESS on success, CSR error code on failure
* ---------------------------------------------------------------------------
*/
-static CsrResult safe_read_shared_location(card_t *card, CsrUint32 address, u8 *pdata)
+static CsrResult safe_read_shared_location(card_t *card, u32 address, u8 *pdata)
{
CsrResult r;
u16 limit = 1000;
#define OPERATION_TIMEOUT_LOOPS (100) /* when OPERATION_TIMEOUT_DELAY==1, (500) otherwise */
#define OPERATION_TIMEOUT_DELAY 1 /* msec, or 200usecs */
-CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, u8 opcode)
+CsrResult unifi_do_loader_op(card_t *card, u32 op_addr, u8 opcode)
{
CsrResult r;
s16 op_retries;
* ---------------------------------------------------------------------------
*/
static CsrResult send_ptdl_to_unifi(card_t *card, void *dlpriv,
- const struct PTDL *ptdl, CsrUint32 handle,
- CsrUint32 op_addr)
+ const struct PTDL *ptdl, u32 handle,
+ u32 op_addr)
{
- CsrUint32 offset;
+ u32 offset;
u8 *buf;
CsrInt32 data_len;
- CsrUint32 write_len;
+ u32 write_len;
CsrResult r;
const u16 buf_size = 2 * 1024;
* CSR_WIFI_HIP_RESULT_INVALID_VALUE for a bad laoader version number
* ---------------------------------------------------------------------------
*/
-static CsrResult do_patch_download(card_t *card, void *dlpriv, xbv1_t *pfwinfo, CsrUint32 boot_ctrl_addr)
+static CsrResult do_patch_download(card_t *card, void *dlpriv, xbv1_t *pfwinfo, u32 boot_ctrl_addr)
{
CsrResult r;
CsrInt32 i;
u16 loader_version;
u16 handle;
- CsrUint32 total_bytes;
+ u32 total_bytes;
/*
* Read info from the SDIO Loader Control Data Structure
CsrTime timestamp; /* host's system time at capture */
s16 requestor; /* request: 0=auto dump, 1=manual */
u16 chip_ver;
- CsrUint32 fw_ver;
+ u32 fw_ver;
u16 *zone[HIP_CDUMP_NUM_ZONES];
struct coredump_buf *next; /* circular list */
{
unifi_coredump_space_t space; /* XAP memory space this zone covers */
enum unifi_dbg_processors_select cpu; /* XAP CPU core selector */
- CsrUint32 gp; /* Generic Pointer to memory zone on XAP */
+ u32 gp; /* Generic Pointer to memory zone on XAP */
u16 offset; /* 16-bit XAP word offset of zone in memory space */
u16 length; /* Length of zone in XAP words */
};
{
CsrInt32 r = -1;
u16 offset_in_zone;
- CsrUint32 zone_end_offset;
+ u32 zone_end_offset;
CsrInt32 i;
const struct coredump_zone *def = &zonedef_table[0];
{
u16 val;
CsrResult r;
- CsrUint32 sdio_addr;
+ u32 sdio_addr;
func_enter();
coredump_buffer *newnode = NULL;
u16 *newzone = NULL;
CsrInt32 i;
- CsrUint32 zone_size;
+ u32 zone_size;
/* Allocate node header */
newnode = (coredump_buffer *)CsrMemAlloc(sizeof(coredump_buffer));
void *ospriv = card->ospriv;
coredump_buffer *prev = NULL;
coredump_buffer *newnode = NULL;
- CsrUint32 i = 0;
+ u32 i = 0;
#endif
func_enter();
* Calls unifi_pause_xmit() when the last slots are used.
* ---------------------------------------------------------------------------
*/
-static CsrResult send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
+static CsrResult send_signal(card_t *card, const u8 *sigptr, u32 siglen,
const bulk_data_param_t *bulkdata,
- q_t *sigq, CsrUint32 priority_q, CsrUint32 run_bh)
+ q_t *sigq, u32 priority_q, u32 run_bh)
{
u16 i, data_slot_size;
card_signal_t *csptr;
{
if ((bulkdata != NULL) && (bulkdata->d[i].data_length != 0))
{
- CsrUint32 datalen = bulkdata->d[i].data_length;
+ u32 datalen = bulkdata->d[i].data_length;
/* Make sure data will fit in a bulk data slot */
if (bulkdata->d[i].os_data_ptr == NULL)
* to the device. Signals are constructed using the UniFi packed structures.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
+CsrResult unifi_send_signal(card_t *card, const u8 *sigptr, u32 siglen,
const bulk_data_param_t *bulkdata)
{
q_t *sig_soft_q;
u16 signal_id;
CsrResult r;
- CsrUint32 run_bh;
- CsrUint32 priority_q;
+ u32 run_bh;
+ u32 priority_q;
/* A NULL signal pointer is a request to check if UniFi is responsive */
if (sigptr == NULL)
if (signal_id == CSR_MA_PACKET_REQUEST_ID)
{
u16 frame_priority;
- CsrUint32 priority_q;
+ u32 priority_q;
/* Map the frame priority to a traffic queue index. */
frame_priority = GET_PACKED_MA_PACKET_REQUEST_FRAME_PRIORITY(sigptr);
}
-CsrUint32 SigGetFilterPos(u16 aSigID)
+u32 SigGetFilterPos(u16 aSigID)
{
switch (aSigID)
{
typedef u16 CSR_CHANNEL_STARTING_FACTOR;
-typedef CsrUint32 CSR_CIPHER_SUITE_SELECTOR;
+typedef u32 CSR_CIPHER_SUITE_SELECTOR;
-typedef CsrUint32 CSR_CLIENT_TAG;
+typedef u32 CSR_CLIENT_TAG;
typedef enum CSR_CONNECTION_STATUS
{
CSR_PROBE_REQUEST = 0x0004
} CSR_FRAME_TYPE;
-typedef CsrUint32 CSR_IPV4_ADDRESS;
+typedef u32 CSR_IPV4_ADDRESS;
typedef enum CSR_IFINTERFACE
{
typedef u16 CSR_MICROSECONDS16;
-typedef CsrUint32 CSR_MICROSECONDS32;
+typedef u32 CSR_MICROSECONDS32;
typedef u16 CSR_NATURAL16;
#define SIG_FILTER_SIZE 6
-CsrUint32 SigGetFilterPos(u16 aSigID);
+u32 SigGetFilterPos(u16 aSigID);
#ifdef __cplusplus
}
u16 proto;
u16 source_port, dest_port;
CsrWifiMacAddress srcAddress;
- CsrUint32 snap_hdr, oui_hdr;
+ u32 snap_hdr, oui_hdr;
if (data->data_length < TA_LLC_HEADER_SIZE)
{
return TA_FRAME_UNKNOWN;
}
- snap_hdr = (((CsrUint32)data->os_data_ptr[0]) << 24) |
- (((CsrUint32)data->os_data_ptr[1]) << 16) |
- (((CsrUint32)data->os_data_ptr[2]) << 8);
+ snap_hdr = (((u32)data->os_data_ptr[0]) << 24) |
+ (((u32)data->os_data_ptr[1]) << 16) |
+ (((u32)data->os_data_ptr[2]) << 8);
if (snap_hdr != snap_802_2)
{
return TA_FRAME_UNKNOWN;
*/
}
- oui_hdr = (((CsrUint32)data->os_data_ptr[3]) << 24) |
- (((CsrUint32)data->os_data_ptr[4]) << 16) |
- (((CsrUint32)data->os_data_ptr[5]) << 8);
+ oui_hdr = (((u32)data->os_data_ptr[3]) << 24) |
+ (((u32)data->os_data_ptr[4]) << 16) |
+ (((u32)data->os_data_ptr[5]) << 8);
if ((oui_hdr == oui_rfc1042) || (oui_hdr == oui_8021h))
{
proto = (data->os_data_ptr[TA_ETHERNET_TYPE_OFFSET] * 256) +
const bulk_data_desc_t *data,
const u8 *saddr,
const u8 *sta_macaddr,
- CsrUint32 timestamp,
+ u32 timestamp,
u16 rate)
{
ta_data_t *tad = &card->ta_sampling;
enum ta_frame_identity identity;
- CsrUint32 time_delta;
+ u32 time_delta;
*/
if (tad->stats.txFramesNum < TA_MAX_INTERVALS_IN_C1)
{
- CsrUint32 interval;
- CsrUint32 index_in_intervals;
+ u32 interval;
+ u32 index_in_intervals;
interval = timestamp - tad->tx_last_ts;
tad->tx_last_ts = timestamp;
* rxFramesNum can be flashed in tas_reset_data() by another thread.
* Use a temp to avoid division by zero.
*/
- CsrUint32 temp_rxFramesNum;
+ u32 temp_rxFramesNum;
temp_rxFramesNum = tad->stats.rxFramesNum;
/* Calculate this interval's mean frame Rx rate from the sum */
*/
if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
{
- CsrUint32 rxTcpThroughput = tad->ta_l4stats.rxTcpBytesCount / time_delta;
- CsrUint32 txTcpThroughput = tad->ta_l4stats.txTcpBytesCount / time_delta;
- CsrUint32 rxUdpThroughput = tad->ta_l4stats.rxUdpBytesCount / time_delta;
- CsrUint32 txUdpThroughput = tad->ta_l4stats.txUdpBytesCount / time_delta;
+ u32 rxTcpThroughput = tad->ta_l4stats.rxTcpBytesCount / time_delta;
+ u32 txTcpThroughput = tad->ta_l4stats.txTcpBytesCount / time_delta;
+ u32 rxUdpThroughput = tad->ta_l4stats.rxUdpBytesCount / time_delta;
+ u32 txUdpThroughput = tad->ta_l4stats.txUdpBytesCount / time_delta;
unifi_ta_indicate_l4stats(card->ospriv,
rxTcpThroughput,
typedef struct ta_l4stats
{
- CsrUint32 rxTcpBytesCount;
- CsrUint32 txTcpBytesCount;
- CsrUint32 rxUdpBytesCount;
- CsrUint32 txUdpBytesCount;
+ u32 rxTcpBytesCount;
+ u32 txTcpBytesCount;
+ u32 rxUdpBytesCount;
+ u32 txUdpBytesCount;
} ta_l4stats_t;
/*
CsrWifiRouterCtrlTrafficFilter custom_filter;
/* The timestamp of the last tx packet processed. */
- CsrUint32 tx_last_ts;
+ u32 tx_last_ts;
/* The timestamp of the last packet processed. */
- CsrUint32 last_indication_time;
+ u32 last_indication_time;
/* Statistics */
CsrWifiRouterCtrlTrafficStats stats;
CsrWifiRouterCtrlTrafficType traffic_type;
/* Sum of packet rx rates for this interval used to calculate mean */
- CsrUint32 rx_sum_rate;
+ u32 rx_sum_rate;
ta_l4stats_t ta_l4stats;
} ta_data_t;
typedef struct _bulk_data_desc
{
const u8 *os_data_ptr;
- CsrUint32 data_length;
+ u32 data_length;
const void *os_net_buf_ptr;
- CsrUint32 net_buf_length;
+ u32 net_buf_length;
} bulk_data_desc_t;
/* Structure of an entry in the Symbol Look Up Table (SLUT). */
typedef struct _symbol
{
u16 id;
- CsrUint32 obj;
+ u32 obj;
} symbol_t;
/*
{
u16 chip_id;
u16 chip_version;
- CsrUint32 fw_build;
+ u32 fw_build;
u16 fw_hip_version;
- CsrUint32 sdio_block_size;
+ u32 sdio_block_size;
} card_info_t;
/* From user */
CsrInt32 index; /* 0=newest, -1=oldest */
unifi_coredump_space_t space; /* memory space */
- CsrUint32 offset; /* register offset in space */
+ u32 offset; /* register offset in space */
/* From driver */
- CsrUint32 drv_build; /* Driver build id */
- CsrUint32 chip_ver; /* Chip version */
- CsrUint32 fw_ver; /* Firmware version */
+ u32 drv_build; /* Driver build id */
+ u32 chip_ver; /* Chip version */
+ u32 fw_ver; /* Firmware version */
CsrInt32 requestor; /* Requestor: 0=auto dump, 1=manual */
CsrTime timestamp; /* time of capture by driver */
- CsrUint32 serial; /* capture serial number */
+ u32 serial; /* capture serial number */
CsrInt32 value; /* register value */
} unifi_coredump_req_t; /* mini-coredumped reg value request */
* @ingroup upperedge
*/
CsrResult unifi_send_signal(card_t *card, const u8 *sigptr,
- CsrUint32 siglen,
+ u32 siglen,
const bulk_data_param_t *bulkdata);
/**
*
* @ingroup upperedge
*/
-CsrResult unifi_bh(card_t *card, CsrUint32 *remaining);
+CsrResult unifi_bh(card_t *card, u32 *remaining);
/**
const bulk_data_desc_t *data,
const u8 *saddr,
const u8 *sta_macaddr,
- CsrUint32 timestamp,
+ u32 timestamp,
u16 rate);
/**
CsrResult unifi_card_hard_reset(card_t *card);
-CsrResult unifi_card_readn(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len);
-CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, u16 *pdata);
-CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, u16 data);
+CsrResult unifi_card_readn(card_t *card, u32 unifi_addr, void *pdata, u16 len);
+CsrResult unifi_card_read16(card_t *card, u32 unifi_addr, u16 *pdata);
+CsrResult unifi_card_write16(card_t *card, u32 unifi_addr, u16 data);
enum unifi_dbg_processors_select
* @ingroup upperedge
*/
void unifi_receive_event(void *ospriv,
- u8 *sigdata, CsrUint32 siglen,
+ u8 *sigdata, u32 siglen,
const bulk_data_param_t *bulkdata);
#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
*
* @ingroup upperedge
*/
-CsrResult unifi_reque_ma_packet_request(void *ospriv, CsrUint32 host_tag,
+CsrResult unifi_reque_ma_packet_request(void *ospriv, u32 host_tag,
u16 status,
bulk_data_desc_t *bulkDataDesc);
*
* @ingroup upperedge
*/
-CsrInt32 unifi_fw_read(void *ospriv, void *arg, CsrUint32 offset, void *buf, CsrUint32 len);
+CsrInt32 unifi_fw_read(void *ospriv, void *arg, u32 offset, void *buf, u32 len);
/**
*
*
* @ingroup upperedge
*/
-void* unifi_fw_open_buffer(void *ospriv, void *fwbuf, CsrUint32 len);
+void* unifi_fw_open_buffer(void *ospriv, void *fwbuf, u32 len);
/**
*
*/
void unifi_ta_indicate_sampling(void *ospriv, CsrWifiRouterCtrlTrafficStats *stats);
void unifi_ta_indicate_l4stats(void *ospriv,
- CsrUint32 rxTcpThroughput,
- CsrUint32 txTcpThroughput,
- CsrUint32 rxUdpThroughput,
- CsrUint32 txUdpThroughput);
+ u32 rxTcpThroughput,
+ u32 txTcpThroughput,
+ u32 rxUdpThroughput,
+ u32 txUdpThroughput);
#endif
void unifi_rx_queue_flush(void *ospriv);
#define CSR_WIFI_INTMODE_DEFAULT 0
#define CSR_WIFI_INTMODE_RUN_BH_ONCE 1 /* Run BH once per interrupt */
-void unifi_set_interrupt_mode(card_t *card, CsrUint32 mode);
+void unifi_set_interrupt_mode(card_t *card, u32 mode);
/*
* unifi_request_max_clock() requests that max SDIO clock speed is set at the
};
typedef void (*udi_func_t)(void *ospriv, u8 *sigdata,
- CsrUint32 signal_len,
+ u32 signal_len,
const bulk_data_param_t *bulkdata,
enum udi_log_direction dir);
typedef struct
{
CsrCharString t_name[4];
- CsrUint32 t_len;
+ u32 t_len;
} tag_t;
xbv_container container;
CsrInt32 ioffset_end;
} s[XBV_STACK_SIZE];
- CsrUint32 ptr;
+ u32 ptr;
} xbv_stack_t;
static CsrInt32 read_tag(card_t *card, ct_t *ct, tag_t *tag);
-static CsrInt32 read_bytes(card_t *card, ct_t *ct, void *buf, CsrUint32 len);
-static CsrInt32 read_uint(card_t *card, ct_t *ct, CsrUint32 *u, CsrUint32 len);
+static CsrInt32 read_bytes(card_t *card, ct_t *ct, void *buf, u32 len);
+static CsrInt32 read_uint(card_t *card, ct_t *ct, u32 *u, u32 len);
static CsrInt32 xbv_check(xbv1_t *fwinfo, const xbv_stack_t *stack,
xbv_mode new_mode, xbv_container old_cont);
static CsrInt32 xbv_push(xbv1_t *fwinfo, xbv_stack_t *stack,
xbv_mode new_mode, xbv_container old_cont,
- xbv_container new_cont, CsrUint32 ioff);
+ xbv_container new_cont, u32 ioff);
-static CsrUint32 write_uint16(void *buf, const CsrUint32 offset,
+static u32 write_uint16(void *buf, const u32 offset,
const u16 val);
-static CsrUint32 write_uint32(void *buf, const CsrUint32 offset,
- const CsrUint32 val);
-static CsrUint32 write_bytes(void *buf, const CsrUint32 offset,
- const u8 *data, const CsrUint32 len);
-static CsrUint32 write_tag(void *buf, const CsrUint32 offset,
+static u32 write_uint32(void *buf, const u32 offset,
+ const u32 val);
+static u32 write_bytes(void *buf, const u32 offset,
+ const u8 *data, const u32 len);
+static u32 write_tag(void *buf, const u32 offset,
const CsrCharString *tag_str);
-static CsrUint32 write_chunk(void *buf, const CsrUint32 offset,
+static u32 write_chunk(void *buf, const u32 offset,
const CsrCharString *tag_str,
- const CsrUint32 payload_len);
-static u16 calc_checksum(void *buf, const CsrUint32 offset,
- const CsrUint32 bytes_len);
-static CsrUint32 calc_patch_size(const xbv1_t *fwinfo);
-
-static CsrUint32 write_xbv_header(void *buf, const CsrUint32 offset,
- const CsrUint32 file_payload_length);
-static CsrUint32 write_ptch_header(void *buf, const CsrUint32 offset,
- const CsrUint32 fw_id);
-static CsrUint32 write_patchcmd(void *buf, const CsrUint32 offset,
- const CsrUint32 dst_genaddr, const u16 len);
-static CsrUint32 write_reset_ptdl(void *buf, const CsrUint32 offset,
- const xbv1_t *fwinfo, CsrUint32 fw_id);
-static CsrUint32 write_fwdl_to_ptdl(void *buf, const CsrUint32 offset,
+ const u32 payload_len);
+static u16 calc_checksum(void *buf, const u32 offset,
+ const u32 bytes_len);
+static u32 calc_patch_size(const xbv1_t *fwinfo);
+
+static u32 write_xbv_header(void *buf, const u32 offset,
+ const u32 file_payload_length);
+static u32 write_ptch_header(void *buf, const u32 offset,
+ const u32 fw_id);
+static u32 write_patchcmd(void *buf, const u32 offset,
+ const u32 dst_genaddr, const u16 len);
+static u32 write_reset_ptdl(void *buf, const u32 offset,
+ const xbv1_t *fwinfo, u32 fw_id);
+static u32 write_fwdl_to_ptdl(void *buf, const u32 offset,
fwreadfn_t readfn, const struct FWDL *fwdl,
- const void *fw_buf, const CsrUint32 fw_id,
+ const void *fw_buf, const u32 fw_id,
void *rdbuf);
/*
/* File format version */
if (TAG_EQ(tag.t_name, "VERF"))
{
- CsrUint32 version;
+ u32 version;
if (xbv_check(fwinfo, &stack, xbv_unknown, xbv_xbv1) ||
(tag.t_len != 2) ||
else if (TAG_EQ(tag.t_name, "LIST"))
{
CsrCharString name[4];
- CsrUint32 list_end;
+ u32 list_end;
list_end = ct.ioffset + tag.t_len;
}
else if (TAG_EQ(tag.t_name, "SLTP"))
{
- CsrUint32 addr;
+ u32 addr;
if (xbv_check(fwinfo, &stack, xbv_firmware, xbv_fw) ||
(tag.t_len != 4) ||
}
else if (TAG_EQ(tag.t_name, "FWDL"))
{
- CsrUint32 addr;
+ u32 addr;
struct FWDL *fwdl;
if (xbv_check(fwinfo, &stack, xbv_firmware, xbv_fw) ||
}
else if (TAG_EQ(tag.t_name, "VMEQ"))
{
- CsrUint32 temp[3];
+ u32 temp[3];
struct VAND *vand;
struct VMEQ *vmeq;
}
else if (TAG_EQ(tag.t_name, "FWID"))
{
- CsrUint32 build_id;
+ u32 build_id;
if (xbv_check(fwinfo, &stack, xbv_patch, xbv_ptch) ||
(tag.t_len != 4) ||
/* Make checks as above and then enter a new list */
static CsrInt32 xbv_push(xbv1_t *fwinfo, xbv_stack_t *stack,
xbv_mode new_mode, xbv_container old_cont,
- xbv_container new_cont, CsrUint32 new_ioff)
+ xbv_container new_cont, u32 new_ioff)
{
if (xbv_check(fwinfo, stack, new_mode, old_cont))
{
}
-static CsrUint32 xbv2uint(u8 *ptr, CsrInt32 len)
+static u32 xbv2uint(u8 *ptr, CsrInt32 len)
{
- CsrUint32 u = 0;
+ u32 u = 0;
s16 i;
for (i = 0; i < len; i++)
{
- CsrUint32 b;
+ u32 b;
b = ptr[i];
u += b << (i * 8);
}
} /* read_tag() */
-static CsrInt32 read_bytes(card_t *card, ct_t *ct, void *buf, CsrUint32 len)
+static CsrInt32 read_bytes(card_t *card, ct_t *ct, void *buf, u32 len)
{
/* read the tag value */
if ((*ct->iread)(card->ospriv, ct->dlpriv, ct->ioffset, buf, len) != (CsrInt32)len)
} /* read_bytes() */
-static CsrInt32 read_uint(card_t *card, ct_t *ct, CsrUint32 *u, CsrUint32 len)
+static CsrInt32 read_uint(card_t *card, ct_t *ct, u32 *u, u32 len)
{
u8 buf[4];
} /* read_uint() */
-static CsrUint32 write_uint16(void *buf, const CsrUint32 offset, const u16 val)
+static u32 write_uint16(void *buf, const u32 offset, const u16 val)
{
u8 *dst = (u8 *)buf + offset;
*dst++ = (u8)(val & 0xff); /* LSB first */
}
-static CsrUint32 write_uint32(void *buf, const CsrUint32 offset, const CsrUint32 val)
+static u32 write_uint32(void *buf, const u32 offset, const u32 val)
{
(void)write_uint16(buf, offset + 0, (u16)(val & 0xffff));
(void)write_uint16(buf, offset + 2, (u16)(val >> 16));
- return sizeof(CsrUint32);
+ return sizeof(u32);
}
-static CsrUint32 write_bytes(void *buf, const CsrUint32 offset, const u8 *data, const CsrUint32 len)
+static u32 write_bytes(void *buf, const u32 offset, const u8 *data, const u32 len)
{
- CsrUint32 i;
+ u32 i;
u8 *dst = (u8 *)buf + offset;
for (i = 0; i < len; i++)
}
-static CsrUint32 write_tag(void *buf, const CsrUint32 offset, const CsrCharString *tag_str)
+static u32 write_tag(void *buf, const u32 offset, const CsrCharString *tag_str)
{
u8 *dst = (u8 *)buf + offset;
CsrMemCpy(dst, tag_str, 4);
}
-static CsrUint32 write_chunk(void *buf, const CsrUint32 offset, const CsrCharString *tag_str, const CsrUint32 payload_len)
+static u32 write_chunk(void *buf, const u32 offset, const CsrCharString *tag_str, const u32 payload_len)
{
- CsrUint32 written = 0;
+ u32 written = 0;
written += write_tag(buf, offset, tag_str);
- written += write_uint32(buf, written + offset, (CsrUint32)payload_len);
+ written += write_uint32(buf, written + offset, (u32)payload_len);
return written;
}
-static u16 calc_checksum(void *buf, const CsrUint32 offset, const CsrUint32 bytes_len)
+static u16 calc_checksum(void *buf, const u32 offset, const u32 bytes_len)
{
- CsrUint32 i;
+ u32 i;
u8 *src = (u8 *)buf + offset;
u16 sum = 0;
u16 val;
#define PTDL_RESET_DATA_SIZE 20 /* Size of reset vectors PTDL */
-static CsrUint32 calc_patch_size(const xbv1_t *fwinfo)
+static u32 calc_patch_size(const xbv1_t *fwinfo)
{
s16 i;
- CsrUint32 size = 0;
+ u32 size = 0;
/*
* Work out how big an equivalent patch format file must be for this image.
}
-static CsrUint32 write_xbv_header(void *buf, const CsrUint32 offset, const CsrUint32 file_payload_length)
+static u32 write_xbv_header(void *buf, const u32 offset, const u32 file_payload_length)
{
- CsrUint32 written = 0;
+ u32 written = 0;
/* The length value given to the XBV chunk is the length of all subsequent
* contents of the file, excluding the 8 byte size of the XBV1 header itself
}
-static CsrUint32 write_ptch_header(void *buf, const CsrUint32 offset, const CsrUint32 fw_id)
+static u32 write_ptch_header(void *buf, const u32 offset, const u32 fw_id)
{
- CsrUint32 written = 0;
+ u32 written = 0;
/* LIST is written with a zero length, to be updated later */
written += write_chunk(buf, offset + written, (CsrCharString *)"LIST", 0);
#define UF_MEMPUT_MAC 0x0000
#define UF_MEMPUT_PHY 0x1000
-static CsrUint32 write_patchcmd(void *buf, const CsrUint32 offset, const CsrUint32 dst_genaddr, const u16 len)
+static u32 write_patchcmd(void *buf, const u32 offset, const u32 dst_genaddr, const u16 len)
{
- CsrUint32 written = 0;
- CsrUint32 region = (dst_genaddr >> 28);
+ u32 written = 0;
+ u32 region = (dst_genaddr >> 28);
u16 cmd_and_len = UF_MEMPUT_MAC;
if (region == UF_REGION_PHY)
}
-static CsrUint32 write_fwdl_to_ptdl(void *buf, const CsrUint32 offset, fwreadfn_t readfn,
+static u32 write_fwdl_to_ptdl(void *buf, const u32 offset, fwreadfn_t readfn,
const struct FWDL *fwdl, const void *dlpriv,
- const CsrUint32 fw_id, void *fw_buf)
+ const u32 fw_id, void *fw_buf)
{
- CsrUint32 written = 0;
+ u32 written = 0;
s16 chunks = 0;
- CsrUint32 left = fwdl->dl_size; /* Bytes left in this fwdl */
- CsrUint32 dl_addr = fwdl->dl_addr; /* Target address of fwdl image on XAP */
- CsrUint32 dl_offs = fwdl->dl_offset; /* Offset of fwdl image data in source */
+ u32 left = fwdl->dl_size; /* Bytes left in this fwdl */
+ u32 dl_addr = fwdl->dl_addr; /* Target address of fwdl image on XAP */
+ u32 dl_offs = fwdl->dl_offset; /* Offset of fwdl image data in source */
u16 csum;
- CsrUint32 csum_start_offs; /* first offset to include in checksum */
- CsrUint32 sec_data_len; /* section data byte count */
- CsrUint32 sec_len; /* section data + header byte count */
+ u32 csum_start_offs; /* first offset to include in checksum */
+ u32 sec_data_len; /* section data byte count */
+ u32 sec_len; /* section data + header byte count */
/* FWDL maps to one or more PTDLs, as max size for a PTDL is 1K words */
while (left)
#define UF_MAC_START_CMD 0x6000 /* MAC "Set start address" command */
#define UF_PHY_START_CMD 0x7000 /* PHY "Set start address" command */
-static CsrUint32 write_reset_ptdl(void *buf, const CsrUint32 offset, const xbv1_t *fwinfo, CsrUint32 fw_id)
+static u32 write_reset_ptdl(void *buf, const u32 offset, const xbv1_t *fwinfo, u32 fw_id)
{
- CsrUint32 written = 0;
+ u32 written = 0;
u16 csum;
- CsrUint32 csum_start_offs; /* first offset to include in checksum */
- CsrUint32 sec_len; /* section data + header byte count */
+ u32 csum_start_offs; /* first offset to include in checksum */
+ u32 sec_len; /* section data + header byte count */
sec_len = SEC_CMD_LEN + PTDL_VEC_HDR_SIZE; /* Total section byte length */
* ---------------------------------------------------------------------------
*/
CsrInt32 xbv1_read_slut(card_t *card, fwreadfn_t readfn, void *dlpriv, xbv1_t *fwinfo,
- symbol_t *slut, CsrUint32 slut_len)
+ symbol_t *slut, u32 slut_len)
{
s16 i;
CsrInt32 offset;
- CsrUint32 magic;
- CsrUint32 count = 0;
+ u32 magic;
+ u32 count = 0;
ct_t ct;
if (fwinfo->mode != xbv_firmware)
while (count < slut_len)
{
- CsrUint32 id, obj;
+ u32 id, obj;
/* Read Symbol Id */
if (read_uint(card, &ct, &id, 2))
#define PTCH_LIST_SIZE 16 /* sizeof PTCH+FWID chunk in LIST header */
void* xbv_to_patch(card_t *card, fwreadfn_t readfn,
- const void *fw_buf, const xbv1_t *fwinfo, CsrUint32 *size)
+ const void *fw_buf, const xbv1_t *fwinfo, u32 *size)
{
void *patch_buf = NULL;
- CsrUint32 patch_buf_size;
- CsrUint32 payload_offs = 0; /* Start of XBV payload */
+ u32 patch_buf_size;
+ u32 payload_offs = 0; /* Start of XBV payload */
s16 i;
- CsrUint32 patch_offs = 0;
- CsrUint32 list_len_offs = 0; /* Offset of PTDL LIST length parameter */
- CsrUint32 ptdl_start_offs = 0; /* Offset of first PTDL chunk */
- CsrUint32 fw_id;
+ u32 patch_offs = 0;
+ u32 list_len_offs = 0; /* Offset of PTDL LIST length parameter */
+ u32 ptdl_start_offs = 0; /* Offset of first PTDL chunk */
+ u32 fw_id;
void *rdbuf;
if (!fw_buf || !fwinfo || !card)
struct VMEQ
{
- CsrUint32 addr;
+ u32 addr;
u16 mask;
u16 value;
};
struct VAND
{
- CsrUint32 first;
- CsrUint32 count;
+ u32 first;
+ u32 count;
};
struct VERS
{
- CsrUint32 num_vand;
+ u32 num_vand;
};
struct FWDL
{
- CsrUint32 dl_addr;
- CsrUint32 dl_size;
- CsrUint32 dl_offset;
+ u32 dl_addr;
+ u32 dl_size;
+ u32 dl_offset;
};
struct FWOV
{
- CsrUint32 dl_size;
- CsrUint32 dl_offset;
+ u32 dl_size;
+ u32 dl_offset;
};
struct PTDL
{
- CsrUint32 dl_size;
- CsrUint32 dl_offset;
+ u32 dl_size;
+ u32 dl_offset;
};
#define MAX_VMEQ 64
/* Parts of a Firmware XBV1 */
struct VMEQ vmeq[MAX_VMEQ];
- CsrUint32 num_vmeq;
+ u32 num_vmeq;
struct VAND vand[MAX_VAND];
struct VERS vers;
- CsrUint32 slut_addr;
+ u32 slut_addr;
/* F/W download image, possibly more than one part */
struct FWDL fwdl[MAX_FWDL];
/* Parts of a Patch XBV1 */
- CsrUint32 build_id;
+ u32 build_id;
struct PTDL ptdl[MAX_PTDL];
s16 num_ptdl;
} xbv1_t;
-typedef CsrInt32 (*fwreadfn_t)(void *ospriv, void *dlpriv, CsrUint32 offset, void *buf, CsrUint32 len);
+typedef CsrInt32 (*fwreadfn_t)(void *ospriv, void *dlpriv, u32 offset, void *buf, u32 len);
CsrResult xbv1_parse(card_t *card, fwreadfn_t readfn, void *dlpriv, xbv1_t *fwinfo);
CsrInt32 xbv1_read_slut(card_t *card, fwreadfn_t readfn, void *dlpriv, xbv1_t *fwinfo,
- symbol_t *slut, CsrUint32 slut_len);
+ symbol_t *slut, u32 slut_len);
void* xbv_to_patch(card_t *card, fwreadfn_t readfn, const void *fw_buf, const xbv1_t *fwinfo,
- CsrUint32 *size);
+ u32 *size);
#ifdef __cplusplus
}
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint32 value;
+ u32 value;
} CsrWifiEventCsrUint32;
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrWifiEventCsrUint32
*
*----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint32* CsrWifiEventCsrUint32_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint32 value);
+CsrWifiEventCsrUint32* CsrWifiEventCsrUint32_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src, u32 value);
typedef struct
{
void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, u16 v);
-void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v);
-void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v);
+void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, u32 v);
+void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, u32 v);
void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset);
-void CsrUint24DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset);
-void CsrUint32DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset);
+void CsrUint24DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset);
+void CsrUint32DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset);
-void CsrUint24Ser(u8 *ptr, CsrSize *len, CsrUint32 v);
-void CsrUint24Des(CsrUint32 *v, u8 *buffer, CsrSize *offset);
+void CsrUint24Ser(u8 *ptr, CsrSize *len, u32 v);
+void CsrUint24Des(u32 *v, u8 *buffer, CsrSize *offset);
CsrSize CsrWifiEventSizeof(void *msg);
- Used to register for all available indications
*******************************************************************************/
-typedef CsrUint32 CsrWifiNmeIndications;
+typedef u32 CsrWifiNmeIndications;
#define CSR_WIFI_NME_INDICATIONS_IND_AP_STATION ((CsrWifiNmeIndications) 0x00100000)
#define CSR_WIFI_NME_INDICATIONS_IND_AP_STOP ((CsrWifiNmeIndications) 0x00200000)
#define CSR_WIFI_NME_INDICATIONS_IND_SIM_UMTS_AUTH ((CsrWifiNmeIndications) 0x01000000)
Mask type for use with the values defined by CsrWifiNmeIndications
*******************************************************************************/
-typedef CsrUint32 CsrWifiNmeIndicationsMask;
+typedef u32 CsrWifiNmeIndicationsMask;
/*******************************************************************************
NAME
specific indications
*******************************************************************************/
-typedef CsrUint32 CsrWifiNmeNmeIndicationsMask;
+typedef u32 CsrWifiNmeNmeIndicationsMask;
/*******************************************************************************
NAME
*******************************************************************************/
typedef struct
{
- CsrUint32 certificateLength;
+ u32 certificateLength;
u8 *certificate;
u16 privateKeyLength;
u8 *privateKey;
- CsrUint32 caCertificateLength;
+ u32 caCertificateLength;
u8 *caCertificate;
} CsrWifiNmeWapiCredentials;
CsrCharString *userName;
CsrCharString *userPassword;
CsrCharString *authServerUserIdentity;
- CsrUint32 clientCertificateLength;
+ u32 clientCertificateLength;
u8 *clientCertificate;
- CsrUint32 certificateAuthorityCertificateLength;
+ u32 certificateAuthorityCertificateLength;
u8 *certificateAuthorityCertificate;
u16 privateKeyLength;
u8 *privateKey;
CsrCharString *privateKeyPassword;
- CsrUint32 sessionLength;
+ u32 sessionLength;
u8 *session;
CsrBool allowPacProvisioning;
- CsrUint32 pacLength;
+ u32 pacLength;
u8 *pac;
CsrCharString *pacPassword;
} CsrWifiNmeEapCredentials;
typedef CsrPrim CsrWifiRouterCtrlPrim;
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteWrite)(u8 func, CsrUint32 address, u8 data);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteRead)(u8 func, CsrUint32 address, u8 *pdata);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioFirmwareDownload)(CsrUint32 length, const u8 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteWrite)(u8 func, u32 address, u8 data);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteRead)(u8 func, u32 address, u8 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioFirmwareDownload)(u32 length, const u8 *pdata);
typedef CsrResult (*CsrWifiRouterCtrlRawSdioReset)(void);
typedef CsrResult (*CsrWifiRouterCtrlRawSdioCoreDumpPrepare)(CsrBool suspendSme);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteBlockRead)(u8 func, CsrUint32 address, u8 *pdata, CsrUint32 length);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpRead16)(u8 func, CsrUint32 address, u16 *pdata);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(u8 func, CsrUint32 address, u16 data);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteBlockRead)(u8 func, u32 address, u8 *pdata, u32 length);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpRead16)(u8 func, u32 address, u16 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(u8 func, u32 address, u16 data);
/*******************************************************************************
DESCRIPTION
*******************************************************************************/
-typedef CsrUint32 CsrWifiRouterCtrlPeerRecordHandle;
+typedef u32 CsrWifiRouterCtrlPeerRecordHandle;
/*******************************************************************************
NAME
*******************************************************************************/
typedef struct
{
- CsrUint32 firmwarePatch;
+ u32 firmwarePatch;
CsrCharString *smeBuild;
- CsrUint32 smeHip;
+ u32 smeHip;
} CsrWifiRouterCtrlSmeVersions;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint32 etherType;
+ u32 etherType;
u8 ipType;
- CsrUint32 udpSourcePort;
- CsrUint32 udpDestPort;
+ u32 udpSourcePort;
+ u32 udpDestPort;
} CsrWifiRouterCtrlTrafficFilter;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint32 rxMeanRate;
- CsrUint32 rxFramesNum;
- CsrUint32 txFramesNum;
- CsrUint32 rxBytesCount;
- CsrUint32 txBytesCount;
+ u32 rxMeanRate;
+ u32 rxFramesNum;
+ u32 txFramesNum;
+ u32 rxBytesCount;
+ u32 txBytesCount;
u8 intervals[11];
} CsrWifiRouterCtrlTrafficStats;
*******************************************************************************/
typedef struct
{
- CsrUint32 chipId;
- CsrUint32 chipVersion;
- CsrUint32 firmwareBuild;
- CsrUint32 firmwareHip;
+ u32 chipId;
+ u32 chipVersion;
+ u32 firmwareBuild;
+ u32 firmwareHip;
CsrCharString *routerBuild;
- CsrUint32 routerHip;
+ u32 routerHip;
} CsrWifiRouterCtrlVersions;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint32 dataLength;
+ u32 dataLength;
u8 *data;
} CsrWifiRouterCtrlWifiOnReq;
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrWifiRouterCtrlTrafficConfigType primitive->trafficConfigType */
bufferSize += 2; /* u16 primitive->config.packetFilter */
- bufferSize += 4; /* CsrUint32 primitive->config.customFilter.etherType */
+ bufferSize += 4; /* u32 primitive->config.customFilter.etherType */
bufferSize += 1; /* u8 primitive->config.customFilter.ipType */
- bufferSize += 4; /* CsrUint32 primitive->config.customFilter.udpSourcePort */
- bufferSize += 4; /* CsrUint32 primitive->config.customFilter.udpDestPort */
+ bufferSize += 4; /* u32 primitive->config.customFilter.udpSourcePort */
+ bufferSize += 4; /* u32 primitive->config.customFilter.udpDestPort */
return bufferSize;
}
CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint16Ser(ptr, len, (u16) primitive->trafficConfigType);
CsrUint16Ser(ptr, len, (u16) primitive->config.packetFilter);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.etherType);
+ CsrUint32Ser(ptr, len, (u32) primitive->config.customFilter.etherType);
CsrUint8Ser(ptr, len, (u8) primitive->config.customFilter.ipType);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.udpSourcePort);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.udpDestPort);
+ CsrUint32Ser(ptr, len, (u32) primitive->config.customFilter.udpSourcePort);
+ CsrUint32Ser(ptr, len, (u32) primitive->config.customFilter.udpDestPort);
return(ptr);
}
CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((u16 *) &primitive->trafficConfigType, buffer, &offset);
CsrUint16Des((u16 *) &primitive->config.packetFilter, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.etherType, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->config.customFilter.etherType, buffer, &offset);
CsrUint8Des((u8 *) &primitive->config.customFilter.ipType, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.udpSourcePort, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.udpDestPort, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->config.customFilter.udpSourcePort, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->config.customFilter.udpDestPort, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 4; /* CsrUint32 primitive->dataLength */
+ bufferSize += 4; /* u32 primitive->dataLength */
bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->clientData);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
+ CsrUint32Ser(ptr, len, (u32) primitive->dataLength);
if (primitive->dataLength)
{
CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
bufferSize += 6; /* u8 primitive->stationMacAddress[i1].a[6] */
}
}
- bufferSize += 4; /* CsrUint32 primitive->smeVersions.firmwarePatch */
+ bufferSize += 4; /* u32 primitive->smeVersions.firmwarePatch */
bufferSize += (primitive->smeVersions.smeBuild?CsrStrLen(primitive->smeVersions.smeBuild) : 0) + 1; /* CsrCharString* primitive->smeVersions.smeBuild (0 byte len + 1 for NULL Term) */
- bufferSize += 4; /* CsrUint32 primitive->smeVersions.smeHip */
+ bufferSize += 4; /* u32 primitive->smeVersions.smeHip */
bufferSize += 1; /* CsrBool primitive->scheduledInterrupt */
return bufferSize;
}
CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((u16) (6)));
}
}
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->smeVersions.firmwarePatch);
+ CsrUint32Ser(ptr, len, (u32) primitive->smeVersions.firmwarePatch);
CsrCharStringSer(ptr, len, primitive->smeVersions.smeBuild);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->smeVersions.smeHip);
+ CsrUint32Ser(ptr, len, (u32) primitive->smeVersions.smeHip);
CsrUint8Ser(ptr, len, (u8) primitive->scheduledInterrupt);
return(ptr);
}
CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((u16) (6)));
}
}
- CsrUint32Des((CsrUint32 *) &primitive->smeVersions.firmwarePatch, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->smeVersions.firmwarePatch, buffer, &offset);
CsrCharStringDes(&primitive->smeVersions.smeBuild, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->smeVersions.smeHip, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->smeVersions.smeHip, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scheduledInterrupt, buffer, &offset);
return primitive;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (u16) primitive->clientData);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
+ CsrUint32Ser(ptr, len, (u32) primitive->peerRecordHandle);
return(ptr);
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->peerRecordHandle, buffer, &offset);
return primitive;
}
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (u16) primitive->clientData);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
+ CsrUint32Ser(ptr, len, (u32) primitive->peerRecordHandle);
CsrUint16Ser(ptr, len, (u16) primitive->powersaveMode);
return(ptr);
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->peerRecordHandle, buffer, &offset);
CsrUint16Des((u16 *) &primitive->powersaveMode, buffer, &offset);
return primitive;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 38) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* u16 primitive->interfaceTag */
- bufferSize += 4; /* CsrUint32 primitive->stats.rxMeanRate */
- bufferSize += 4; /* CsrUint32 primitive->stats.rxFramesNum */
- bufferSize += 4; /* CsrUint32 primitive->stats.txFramesNum */
- bufferSize += 4; /* CsrUint32 primitive->stats.rxBytesCount */
- bufferSize += 4; /* CsrUint32 primitive->stats.txBytesCount */
+ bufferSize += 4; /* u32 primitive->stats.rxMeanRate */
+ bufferSize += 4; /* u32 primitive->stats.rxFramesNum */
+ bufferSize += 4; /* u32 primitive->stats.txFramesNum */
+ bufferSize += 4; /* u32 primitive->stats.rxBytesCount */
+ bufferSize += 4; /* u32 primitive->stats.txBytesCount */
bufferSize += 11; /* u8 primitive->stats.intervals[11] */
return bufferSize;
}
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.rxMeanRate);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.rxFramesNum);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.txFramesNum);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.rxBytesCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.txBytesCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->stats.rxMeanRate);
+ CsrUint32Ser(ptr, len, (u32) primitive->stats.rxFramesNum);
+ CsrUint32Ser(ptr, len, (u32) primitive->stats.txFramesNum);
+ CsrUint32Ser(ptr, len, (u32) primitive->stats.rxBytesCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->stats.txBytesCount);
CsrMemCpySer(ptr, len, (const void *) primitive->stats.intervals, ((u16) (11)));
return(ptr);
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->stats.rxMeanRate, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->stats.rxFramesNum, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->stats.txFramesNum, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->stats.rxBytesCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->stats.txBytesCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->stats.rxMeanRate, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->stats.rxFramesNum, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->stats.txFramesNum, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->stats.rxBytesCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->stats.txBytesCount, buffer, &offset);
CsrMemCpyDes(primitive->stats.intervals, buffer, &offset, ((u16) (11)));
return primitive;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 27) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 4; /* CsrUint32 primitive->versions.chipId */
- bufferSize += 4; /* CsrUint32 primitive->versions.chipVersion */
- bufferSize += 4; /* CsrUint32 primitive->versions.firmwareBuild */
- bufferSize += 4; /* CsrUint32 primitive->versions.firmwareHip */
+ bufferSize += 4; /* u32 primitive->versions.chipId */
+ bufferSize += 4; /* u32 primitive->versions.chipVersion */
+ bufferSize += 4; /* u32 primitive->versions.firmwareBuild */
+ bufferSize += 4; /* u32 primitive->versions.firmwareHip */
bufferSize += (primitive->versions.routerBuild?CsrStrLen(primitive->versions.routerBuild) : 0) + 1; /* CsrCharString* primitive->versions.routerBuild (0 byte len + 1 for NULL Term) */
- bufferSize += 4; /* CsrUint32 primitive->versions.routerHip */
+ bufferSize += 4; /* u32 primitive->versions.routerHip */
return bufferSize;
}
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint16Ser(ptr, len, (u16) primitive->status);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipId);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipVersion);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwareBuild);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwareHip);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.chipId);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.chipVersion);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.firmwareBuild);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.firmwareHip);
CsrCharStringSer(ptr, len, primitive->versions.routerBuild);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.routerHip);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.routerHip);
return(ptr);
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.chipId, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.chipVersion, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.firmwareBuild, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.firmwareHip, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.chipId, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.chipVersion, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.firmwareBuild, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.firmwareHip, buffer, &offset);
CsrCharStringDes(&primitive->versions.routerBuild, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.routerHip, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.routerHip, buffer, &offset);
return primitive;
}
CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
+ CsrUint32Ser(ptr, len, (u32) primitive->peerRecordHandle);
CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
- CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->peerRecordHandle, buffer, &offset);
CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
CSR_WIFI_ROUTER_OUI_BT -
*******************************************************************************/
-typedef CsrUint32 CsrWifiRouterOui;
+typedef u32 CsrWifiRouterOui;
#define CSR_WIFI_ROUTER_OUI_RFC_1042 ((CsrWifiRouterOui) 0x000000)
#define CSR_WIFI_ROUTER_OUI_BT ((CsrWifiRouterOui) 0x001958)
u16 interfaceTag;
CsrWifiRouterEncapsulation encapsulation;
u16 protocol;
- CsrUint32 oui;
+ u32 oui;
} CsrWifiRouterMaPacketSubscribeReq;
/*******************************************************************************
u8 *frame;
CsrWifiRouterFrameFreeFunction freeFunction;
CsrWifiRouterPriority priority;
- CsrUint32 hostTag;
+ u32 hostTag;
CsrBool cfmRequested;
} CsrWifiRouterMaPacketReq;
{
CsrWifiFsmEvent common;
u16 interfaceTag;
- CsrUint32 hostTag;
+ u32 hostTag;
CsrWifiRouterPriority priority;
CsrWifiMacAddress peerMacAddress;
} CsrWifiRouterMaPacketCancelReq;
CsrWifiFsmEvent common;
u16 interfaceTag;
CsrResult result;
- CsrUint32 hostTag;
+ u32 hostTag;
u16 rate;
} CsrWifiRouterMaPacketCfm;
bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiRouterEncapsulation primitive->encapsulation */
bufferSize += 2; /* u16 primitive->protocol */
- bufferSize += 4; /* CsrUint32 primitive->oui */
+ bufferSize += 4; /* u32 primitive->oui */
return bufferSize;
}
CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->encapsulation);
CsrUint16Ser(ptr, len, (u16) primitive->protocol);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->oui);
+ CsrUint32Ser(ptr, len, (u32) primitive->oui);
return(ptr);
}
CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->encapsulation, buffer, &offset);
CsrUint16Des((u16 *) &primitive->protocol, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->oui, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->oui, buffer, &offset);
return primitive;
}
bufferSize += primitive->frameLength; /* u8 primitive->frame */
bufferSize += 4; /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
- bufferSize += 4; /* CsrUint32 primitive->hostTag */
+ bufferSize += 4; /* u32 primitive->hostTag */
bufferSize += 1; /* CsrBool primitive->cfmRequested */
return bufferSize;
}
}
CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
CsrUint16Ser(ptr, len, (u16) primitive->priority);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
+ CsrUint32Ser(ptr, len, (u32) primitive->hostTag);
CsrUint8Ser(ptr, len, (u8) primitive->cfmRequested);
return(ptr);
}
primitive->freeFunction = NULL; /* Special for Function Pointers... */
offset += 4;
CsrUint16Des((u16 *) &primitive->priority, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->hostTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->cfmRequested, buffer, &offset);
return primitive;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
bufferSize += 2; /* u16 primitive->interfaceTag */
- bufferSize += 4; /* CsrUint32 primitive->hostTag */
+ bufferSize += 4; /* u32 primitive->hostTag */
bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
return bufferSize;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
+ CsrUint32Ser(ptr, len, (u32) primitive->hostTag);
CsrUint16Ser(ptr, len, (u16) primitive->priority);
CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
return(ptr);
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->hostTag, buffer, &offset);
CsrUint16Des((u16 *) &primitive->priority, buffer, &offset);
CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->result */
- bufferSize += 4; /* CsrUint32 primitive->hostTag */
+ bufferSize += 4; /* u32 primitive->hostTag */
bufferSize += 2; /* u16 primitive->rate */
return bufferSize;
}
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (u16) primitive->result);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
+ CsrUint32Ser(ptr, len, (u32) primitive->hostTag);
CsrUint16Ser(ptr, len, (u16) primitive->rate);
return(ptr);
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->hostTag, buffer, &offset);
CsrUint16Des((u16 *) &primitive->rate, buffer, &offset);
return primitive;
}
#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
-void CsrSchedMessagePutStringLog(CsrSchedQid q, u16 mi, void *mv, CsrUint32 line, CsrCharString *file)
+void CsrSchedMessagePutStringLog(CsrSchedQid q, u16 mi, void *mv, u32 line, CsrCharString *file)
#else
void CsrSchedMessagePut(CsrSchedQid q, u16 mi, void *mv)
#endif
#include "csr_wifi_msgconv.h"
#include "csr_wifi_lib.h"
-void CsrUint24Des(CsrUint32 *v, u8 *buffer, CsrSize *offset)
+void CsrUint24Des(u32 *v, u8 *buffer, CsrSize *offset)
{
- CsrUint32 val;
+ u32 val;
val = ((buffer[(*offset) + 2] << 16) |
(buffer[(*offset) + 1] << 8) |
}
-void CsrUint24DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset)
+void CsrUint24DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset)
{
- CsrUint32 val;
+ u32 val;
val = ((buffer[(*offset)] << 16) |
(buffer[(*offset) + 1] << 8) |
}
-void CsrUint32DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset)
+void CsrUint32DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset)
{
- CsrUint32 val;
+ u32 val;
val = ((buffer[(*offset)] << 24) |
(buffer[(*offset) + 1] << 16) |
}
-void CsrUint24Ser(u8 *ptr, CsrSize *len, CsrUint32 v)
+void CsrUint24Ser(u8 *ptr, CsrSize *len, u32 v)
{
ptr[(*len) + 2] = (u8)((v & 0x00ff0000) >> 16);
ptr[(*len) + 1] = (u8)((v & 0x0000ff00) >> 8);
}
-void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v)
+void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, u32 v)
{
ptr[(*len)] = (u8)((v & 0xff000000) >> 24);
ptr[(*len) + 1] = (u8)((v & 0x00ff0000) >> 16);
}
-void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v)
+void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, u32 v)
{
ptr[(*len)] = (u8)((v & 0x00ff0000) >> 16);
ptr[(*len) + 1] = (u8)((v & 0x0000ff00) >> 8);
- Used to register for all available indications
*******************************************************************************/
-typedef CsrUint32 CsrWifiSmeIndications;
+typedef u32 CsrWifiSmeIndications;
#define CSR_WIFI_SME_INDICATIONS_NONE ((CsrWifiSmeIndications) 0x00000000)
#define CSR_WIFI_SME_INDICATIONS_WIFIOFF ((CsrWifiSmeIndications) 0x00000001)
#define CSR_WIFI_SME_INDICATIONS_SCANRESULT ((CsrWifiSmeIndications) 0x00000002)
Mask type for use with the values defined by CsrWifiSmeIndications
*******************************************************************************/
-typedef CsrUint32 CsrWifiSmeIndicationsMask;
+typedef u32 CsrWifiSmeIndicationsMask;
/*******************************************************************************
NAME
{
u8 unifiTxDataRate;
u8 unifiRxDataRate;
- CsrUint32 dot11RetryCount;
- CsrUint32 dot11MultipleRetryCount;
- CsrUint32 dot11AckFailureCount;
- CsrUint32 dot11FrameDuplicateCount;
- CsrUint32 dot11FcsErrorCount;
- CsrUint32 dot11RtsSuccessCount;
- CsrUint32 dot11RtsFailureCount;
- CsrUint32 dot11FailedCount;
- CsrUint32 dot11TransmittedFragmentCount;
- CsrUint32 dot11TransmittedFrameCount;
- CsrUint32 dot11WepExcludedCount;
- CsrUint32 dot11WepIcvErrorCount;
- CsrUint32 dot11WepUndecryptableCount;
- CsrUint32 dot11MulticastReceivedFrameCount;
- CsrUint32 dot11MulticastTransmittedFrameCount;
- CsrUint32 dot11ReceivedFragmentCount;
- CsrUint32 dot11Rsna4WayHandshakeFailures;
- CsrUint32 dot11RsnaTkipCounterMeasuresInvoked;
- CsrUint32 dot11RsnaStatsTkipLocalMicFailures;
- CsrUint32 dot11RsnaStatsTkipReplays;
- CsrUint32 dot11RsnaStatsTkipIcvErrors;
- CsrUint32 dot11RsnaStatsCcmpReplays;
- CsrUint32 dot11RsnaStatsCcmpDecryptErrors;
+ u32 dot11RetryCount;
+ u32 dot11MultipleRetryCount;
+ u32 dot11AckFailureCount;
+ u32 dot11FrameDuplicateCount;
+ u32 dot11FcsErrorCount;
+ u32 dot11RtsSuccessCount;
+ u32 dot11RtsFailureCount;
+ u32 dot11FailedCount;
+ u32 dot11TransmittedFragmentCount;
+ u32 dot11TransmittedFrameCount;
+ u32 dot11WepExcludedCount;
+ u32 dot11WepIcvErrorCount;
+ u32 dot11WepUndecryptableCount;
+ u32 dot11MulticastReceivedFrameCount;
+ u32 dot11MulticastTransmittedFrameCount;
+ u32 dot11ReceivedFragmentCount;
+ u32 dot11Rsna4WayHandshakeFailures;
+ u32 dot11RsnaTkipCounterMeasuresInvoked;
+ u32 dot11RsnaStatsTkipLocalMicFailures;
+ u32 dot11RsnaStatsTkipReplays;
+ u32 dot11RsnaStatsTkipIcvErrors;
+ u32 dot11RsnaStatsCcmpReplays;
+ u32 dot11RsnaStatsCcmpDecryptErrors;
} CsrWifiSmeConnectionStats;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint32 chipId;
- CsrUint32 chipVersion;
- CsrUint32 firmwareBuild;
- CsrUint32 firmwarePatch;
- CsrUint32 firmwareHip;
+ u32 chipId;
+ u32 chipVersion;
+ u32 firmwareBuild;
+ u32 firmwarePatch;
+ u32 firmwareHip;
CsrCharString *routerBuild;
- CsrUint32 routerHip;
+ u32 routerHip;
CsrCharString *smeBuild;
- CsrUint32 smeHip;
+ u32 smeHip;
} CsrWifiSmeVersions;
/*******************************************************************************
u16 currentCoexPeriodMs;
u16 currentCoexLatencyMs;
CsrBool hasBtDevice;
- CsrUint32 currentBlackoutDurationUs;
- CsrUint32 currentBlackoutPeriodUs;
+ u32 currentBlackoutDurationUs;
+ u32 currentBlackoutPeriodUs;
CsrWifiSmeCoexScheme currentCoexScheme;
} CsrWifiSmeCoexInfo;
CsrWifiFsmEvent common;
u16 interfaceTag;
CsrWifiSmeListAction action;
- CsrUint32 transactionId;
+ u32 transactionId;
CsrBool strict;
CsrWifiSmeTspecCtrlMask ctrlMask;
u16 tspecLength;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint32 dataLength;
+ u32 dataLength;
u8 *data;
} CsrWifiSmeSetReq;
{
CsrWifiFsmEvent common;
u16 interfaceTag;
- CsrUint32 transactionId;
+ u32 transactionId;
CsrWifiSmeTspecResultCode tspecResultCode;
u16 tspecLength;
u8 *tspec;
CsrWifiFsmEvent common;
u16 interfaceTag;
CsrResult status;
- CsrUint32 transactionId;
+ u32 transactionId;
CsrWifiSmeTspecResultCode tspecResultCode;
u16 tspecLength;
u8 *tspec;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint32 dataLength;
+ u32 dataLength;
u8 *data;
} CsrWifiSmeCoreDumpInd;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
- bufferSize += 4; /* CsrUint32 primitive->transactionId */
+ bufferSize += 4; /* u32 primitive->transactionId */
bufferSize += 1; /* CsrBool primitive->strict */
bufferSize += 1; /* CsrWifiSmeTspecCtrlMask primitive->ctrlMask */
bufferSize += 2; /* u16 primitive->tspecLength */
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->action);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
+ CsrUint32Ser(ptr, len, (u32) primitive->transactionId);
CsrUint8Ser(ptr, len, (u8) primitive->strict);
CsrUint8Ser(ptr, len, (u8) primitive->ctrlMask);
CsrUint16Ser(ptr, len, (u16) primitive->tspecLength);
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->transactionId, buffer, &offset);
CsrUint8Des((u8 *) &primitive->strict, buffer, &offset);
CsrUint8Des((u8 *) &primitive->ctrlMask, buffer, &offset);
CsrUint16Des((u16 *) &primitive->tspecLength, buffer, &offset);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
- bufferSize += 4; /* CsrUint32 primitive->dataLength */
+ bufferSize += 4; /* u32 primitive->dataLength */
bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
+ CsrUint32Ser(ptr, len, (u32) primitive->dataLength);
if (primitive->dataLength)
{
CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
bufferSize += 2; /* u16 primitive->coexInfo.currentCoexPeriodMs */
bufferSize += 2; /* u16 primitive->coexInfo.currentCoexLatencyMs */
bufferSize += 1; /* CsrBool primitive->coexInfo.hasBtDevice */
- bufferSize += 4; /* CsrUint32 primitive->coexInfo.currentBlackoutDurationUs */
- bufferSize += 4; /* CsrUint32 primitive->coexInfo.currentBlackoutPeriodUs */
+ bufferSize += 4; /* u32 primitive->coexInfo.currentBlackoutDurationUs */
+ bufferSize += 4; /* u32 primitive->coexInfo.currentBlackoutPeriodUs */
bufferSize += 1; /* CsrWifiSmeCoexScheme primitive->coexInfo.currentCoexScheme */
return bufferSize;
}
CsrUint16Ser(ptr, len, (u16) primitive->coexInfo.currentCoexPeriodMs);
CsrUint16Ser(ptr, len, (u16) primitive->coexInfo.currentCoexLatencyMs);
CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.hasBtDevice);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->coexInfo.currentBlackoutDurationUs);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->coexInfo.currentBlackoutPeriodUs);
+ CsrUint32Ser(ptr, len, (u32) primitive->coexInfo.currentBlackoutDurationUs);
+ CsrUint32Ser(ptr, len, (u32) primitive->coexInfo.currentBlackoutPeriodUs);
CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentCoexScheme);
return(ptr);
}
CsrUint16Des((u16 *) &primitive->coexInfo.currentCoexPeriodMs, buffer, &offset);
CsrUint16Des((u16 *) &primitive->coexInfo.currentCoexLatencyMs, buffer, &offset);
CsrUint8Des((u8 *) &primitive->coexInfo.hasBtDevice, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->coexInfo.currentBlackoutDurationUs, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->coexInfo.currentBlackoutPeriodUs, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->coexInfo.currentBlackoutDurationUs, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->coexInfo.currentBlackoutPeriodUs, buffer, &offset);
CsrUint8Des((u8 *) &primitive->coexInfo.currentCoexScheme, buffer, &offset);
return primitive;
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* u8 primitive->connectionStats.unifiTxDataRate */
bufferSize += 1; /* u8 primitive->connectionStats.unifiRxDataRate */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RetryCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11MultipleRetryCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11AckFailureCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11FrameDuplicateCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11FcsErrorCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RtsSuccessCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RtsFailureCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11FailedCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11TransmittedFragmentCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11TransmittedFrameCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11WepExcludedCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11WepIcvErrorCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11WepUndecryptableCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11MulticastReceivedFrameCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11MulticastTransmittedFrameCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11ReceivedFragmentCount */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11Rsna4WayHandshakeFailures */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaTkipCounterMeasuresInvoked */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaStatsTkipLocalMicFailures */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaStatsTkipReplays */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaStatsTkipIcvErrors */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaStatsCcmpReplays */
- bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaStatsCcmpDecryptErrors */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11RetryCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11MultipleRetryCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11AckFailureCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11FrameDuplicateCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11FcsErrorCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11RtsSuccessCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11RtsFailureCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11FailedCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11TransmittedFragmentCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11TransmittedFrameCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11WepExcludedCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11WepIcvErrorCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11WepUndecryptableCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11MulticastReceivedFrameCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11MulticastTransmittedFrameCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11ReceivedFragmentCount */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11Rsna4WayHandshakeFailures */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11RsnaTkipCounterMeasuresInvoked */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11RsnaStatsTkipLocalMicFailures */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11RsnaStatsTkipReplays */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11RsnaStatsTkipIcvErrors */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11RsnaStatsCcmpReplays */
+ bufferSize += 4; /* u32 primitive->connectionStats.dot11RsnaStatsCcmpDecryptErrors */
return bufferSize;
}
CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->connectionStats.unifiTxDataRate);
CsrUint8Ser(ptr, len, (u8) primitive->connectionStats.unifiRxDataRate);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RetryCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11MultipleRetryCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11AckFailureCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11FrameDuplicateCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11FcsErrorCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RtsSuccessCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RtsFailureCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11FailedCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11TransmittedFragmentCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11TransmittedFrameCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11WepExcludedCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11WepIcvErrorCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11WepUndecryptableCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11MulticastReceivedFrameCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11MulticastTransmittedFrameCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11ReceivedFragmentCount);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11Rsna4WayHandshakeFailures);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaTkipCounterMeasuresInvoked);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaStatsTkipLocalMicFailures);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaStatsTkipReplays);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaStatsTkipIcvErrors);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaStatsCcmpReplays);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaStatsCcmpDecryptErrors);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11RetryCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11MultipleRetryCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11AckFailureCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11FrameDuplicateCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11FcsErrorCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11RtsSuccessCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11RtsFailureCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11FailedCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11TransmittedFragmentCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11TransmittedFrameCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11WepExcludedCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11WepIcvErrorCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11WepUndecryptableCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11MulticastReceivedFrameCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11MulticastTransmittedFrameCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11ReceivedFragmentCount);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11Rsna4WayHandshakeFailures);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11RsnaTkipCounterMeasuresInvoked);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11RsnaStatsTkipLocalMicFailures);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11RsnaStatsTkipReplays);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11RsnaStatsTkipIcvErrors);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11RsnaStatsCcmpReplays);
+ CsrUint32Ser(ptr, len, (u32) primitive->connectionStats.dot11RsnaStatsCcmpDecryptErrors);
return(ptr);
}
CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionStats.unifiTxDataRate, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionStats.unifiRxDataRate, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RetryCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11MultipleRetryCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11AckFailureCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11FrameDuplicateCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11FcsErrorCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RtsSuccessCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RtsFailureCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11FailedCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11TransmittedFragmentCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11TransmittedFrameCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11WepExcludedCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11WepIcvErrorCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11WepUndecryptableCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11MulticastReceivedFrameCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11MulticastTransmittedFrameCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11ReceivedFragmentCount, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11Rsna4WayHandshakeFailures, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaTkipCounterMeasuresInvoked, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaStatsTkipLocalMicFailures, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaStatsTkipReplays, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaStatsTkipIcvErrors, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaStatsCcmpReplays, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaStatsCcmpDecryptErrors, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11RetryCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11MultipleRetryCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11AckFailureCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11FrameDuplicateCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11FcsErrorCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11RtsSuccessCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11RtsFailureCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11FailedCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11TransmittedFragmentCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11TransmittedFrameCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11WepExcludedCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11WepIcvErrorCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11WepUndecryptableCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11MulticastReceivedFrameCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11MulticastTransmittedFrameCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11ReceivedFragmentCount, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11Rsna4WayHandshakeFailures, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11RsnaTkipCounterMeasuresInvoked, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11RsnaStatsTkipLocalMicFailures, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11RsnaStatsTkipReplays, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11RsnaStatsTkipIcvErrors, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11RsnaStatsCcmpReplays, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->connectionStats.dot11RsnaStatsCcmpDecryptErrors, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* u16 primitive->interfaceTag */
- bufferSize += 4; /* CsrUint32 primitive->transactionId */
+ bufferSize += 4; /* u32 primitive->transactionId */
bufferSize += 1; /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
bufferSize += 2; /* u16 primitive->tspecLength */
bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
+ CsrUint32Ser(ptr, len, (u32) primitive->transactionId);
CsrUint8Ser(ptr, len, (u8) primitive->tspecResultCode);
CsrUint16Ser(ptr, len, (u16) primitive->tspecLength);
if (primitive->tspecLength)
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->transactionId, buffer, &offset);
CsrUint8Des((u8 *) &primitive->tspecResultCode, buffer, &offset);
CsrUint16Des((u16 *) &primitive->tspecLength, buffer, &offset);
if (primitive->tspecLength)
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 4; /* CsrUint32 primitive->transactionId */
+ bufferSize += 4; /* u32 primitive->transactionId */
bufferSize += 1; /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
bufferSize += 2; /* u16 primitive->tspecLength */
bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (u16) primitive->status);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
+ CsrUint32Ser(ptr, len, (u32) primitive->transactionId);
CsrUint8Ser(ptr, len, (u8) primitive->tspecResultCode);
CsrUint16Ser(ptr, len, (u16) primitive->tspecLength);
if (primitive->tspecLength)
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->transactionId, buffer, &offset);
CsrUint8Des((u8 *) &primitive->tspecResultCode, buffer, &offset);
CsrUint16Des((u16 *) &primitive->tspecLength, buffer, &offset);
if (primitive->tspecLength)
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 33) */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 4; /* CsrUint32 primitive->versions.chipId */
- bufferSize += 4; /* CsrUint32 primitive->versions.chipVersion */
- bufferSize += 4; /* CsrUint32 primitive->versions.firmwareBuild */
- bufferSize += 4; /* CsrUint32 primitive->versions.firmwarePatch */
- bufferSize += 4; /* CsrUint32 primitive->versions.firmwareHip */
+ bufferSize += 4; /* u32 primitive->versions.chipId */
+ bufferSize += 4; /* u32 primitive->versions.chipVersion */
+ bufferSize += 4; /* u32 primitive->versions.firmwareBuild */
+ bufferSize += 4; /* u32 primitive->versions.firmwarePatch */
+ bufferSize += 4; /* u32 primitive->versions.firmwareHip */
bufferSize += (primitive->versions.routerBuild?CsrStrLen(primitive->versions.routerBuild) : 0) + 1; /* CsrCharString* primitive->versions.routerBuild (0 byte len + 1 for NULL Term) */
- bufferSize += 4; /* CsrUint32 primitive->versions.routerHip */
+ bufferSize += 4; /* u32 primitive->versions.routerHip */
bufferSize += (primitive->versions.smeBuild?CsrStrLen(primitive->versions.smeBuild) : 0) + 1; /* CsrCharString* primitive->versions.smeBuild (0 byte len + 1 for NULL Term) */
- bufferSize += 4; /* CsrUint32 primitive->versions.smeHip */
+ bufferSize += 4; /* u32 primitive->versions.smeHip */
return bufferSize;
}
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (u16) primitive->status);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipId);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipVersion);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwareBuild);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwarePatch);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwareHip);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.chipId);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.chipVersion);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.firmwareBuild);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.firmwarePatch);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.firmwareHip);
CsrCharStringSer(ptr, len, primitive->versions.routerBuild);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.routerHip);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.routerHip);
CsrCharStringSer(ptr, len, primitive->versions.smeBuild);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.smeHip);
+ CsrUint32Ser(ptr, len, (u32) primitive->versions.smeHip);
return(ptr);
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.chipId, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.chipVersion, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.firmwareBuild, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.firmwarePatch, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.firmwareHip, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.chipId, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.chipVersion, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.firmwareBuild, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.firmwarePatch, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.firmwareHip, buffer, &offset);
CsrCharStringDes(&primitive->versions.routerBuild, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.routerHip, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.routerHip, buffer, &offset);
CsrCharStringDes(&primitive->versions.smeBuild, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->versions.smeHip, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->versions.smeHip, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
- bufferSize += 4; /* CsrUint32 primitive->dataLength */
+ bufferSize += 4; /* u32 primitive->dataLength */
bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
+ CsrUint32Ser(ptr, len, (u32) primitive->dataLength);
if (primitive->dataLength)
{
CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
+ CsrUint32Des((u32 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
/* Apply scheduled interrupt mode, if requested by module param */
if (run_bh_once != -1) {
- unifi_set_interrupt_mode(priv->card, (CsrUint32)run_bh_once);
+ unifi_set_interrupt_mode(priv->card, (u32)run_bh_once);
}
priv->init_progress = UNIFI_INIT_COMPLETED;
static void
udi_set_log_filter(ul_client_t *pcli, unifiio_filter_t *udi_filter)
{
- CsrUint32 filter_pos;
+ u32 filter_pos;
int i;
if (udi_filter->action == UfSigFil_AllOn)
int i;
int total_len;
udi_msg_t *msgptr;
- CsrUint32 filter_pos;
+ u32 filter_pos;
#ifdef OMNICLI_LINUX_EXTRA_LOG
static volatile unsigned int printk_cpu = UINT_MAX;
unsigned long long t;
* ---------------------------------------------------------------------------
*/
void *
-unifi_fw_open_buffer(void *ospriv, void *fwbuf, CsrUint32 len)
+unifi_fw_open_buffer(void *ospriv, void *fwbuf, u32 len)
{
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
func_enter();
* ---------------------------------------------------------------------------
*/
CsrInt32
-unifi_fw_read(void *ospriv, void *arg, CsrUint32 offset, void *buf, CsrUint32 len)
+unifi_fw_read(void *ospriv, void *arg, u32 offset, void *buf, u32 len)
{
const struct dlpriv *dlpriv = arg;
static void
process_amsdu(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
{
- CsrUint32 offset;
- CsrUint32 length = bulkdata->d[0].data_length;
- CsrUint32 subframe_length, subframe_body_length, dot11_hdr_size;
+ u32 offset;
+ u32 length = bulkdata->d[0].data_length;
+ u32 subframe_length, subframe_body_length, dot11_hdr_size;
u8 *ptr;
bulk_data_param_t subframe_bulkdata;
u8 *dot11_hdr_ptr = (u8*)bulkdata->d[0].os_data_ptr;
CsrResult
-CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, u8 *data)
+CsrSdioRead8(CsrSdioFunction *function, u32 address, u8 *data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err = 0;
} /* CsrSdioRead8() */
CsrResult
-CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, u8 data)
+CsrSdioWrite8(CsrSdioFunction *function, u32 address, u8 data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err = 0;
} /* CsrSdioWrite8() */
CsrResult
-CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, u16 *data)
+CsrSdioRead16(CsrSdioFunction *function, u32 address, u16 *data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err;
CsrResult
-CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, u16 data)
+CsrSdioWrite16(CsrSdioFunction *function, u32 address, u16 data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err;
CsrResult
-CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, u8 *data)
+CsrSdioF0Read8(CsrSdioFunction *function, u32 address, u8 *data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err = 0;
} /* CsrSdioF0Read8() */
CsrResult
-CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, u8 data)
+CsrSdioF0Write8(CsrSdioFunction *function, u32 address, u8 data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err = 0;
CsrResult
-CsrSdioRead(CsrSdioFunction *function, CsrUint32 address, void *data, CsrUint32 length)
+CsrSdioRead(CsrSdioFunction *function, u32 address, void *data, u32 length)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err;
} /* CsrSdioRead() */
CsrResult
-CsrSdioWrite(CsrSdioFunction *function, CsrUint32 address, const void *data, CsrUint32 length)
+CsrSdioWrite(CsrSdioFunction *function, u32 address, const void *data, u32 length)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err;
* ---------------------------------------------------------------------------
*/
CsrResult
-CsrSdioMaxBusClockFrequencySet(CsrSdioFunction *function, CsrUint32 maxFrequency)
+CsrSdioMaxBusClockFrequencySet(CsrSdioFunction *function, u32 maxFrequency)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
struct mmc_host *host = func->card->host;
struct mmc_ios *ios = &host->ios;
unsigned int max_hz;
int err;
- CsrUint32 max_khz = maxFrequency/1000;
+ u32 max_khz = maxFrequency/1000;
if (!max_khz || max_khz > sdio_clock) {
max_khz = sdio_clock;
}
int sme_mgt_tspec(unifi_priv_t *priv, CsrWifiSmeListAction action,
- CsrUint32 tid, CsrWifiSmeDataBlock *tspec, CsrWifiSmeDataBlock *tclas)
+ u32 tid, CsrWifiSmeDataBlock *tspec, CsrWifiSmeDataBlock *tclas)
{
int r;
void
unifi_ta_indicate_l4stats(void *ospriv,
- CsrUint32 rxTcpThroughput,
- CsrUint32 txTcpThroughput,
- CsrUint32 rxUdpThroughput,
- CsrUint32 txUdpThroughput)
+ u32 rxTcpThroughput,
+ u32 txTcpThroughput,
+ u32 rxUdpThroughput,
+ u32 txUdpThroughput)
{
} /* unifi_ta_indicate_l4stats() */
if (res->status == CSR_RESULT_SUCCESS)
{
int i; /* used as a loop counter */
- CsrUint32 intmode = CSR_WIFI_INTMODE_DEFAULT;
+ u32 intmode = CSR_WIFI_INTMODE_DEFAULT;
#ifdef CSR_WIFI_SPLIT_PATCH
CsrBool switching_ap_fw = FALSE;
#endif
* but let module param override.
*/
if (run_bh_once != -1) {
- intmode = (CsrUint32)run_bh_once;
+ intmode = (u32)run_bh_once;
} else if (res->scheduledInterrupt) {
intmode = CSR_WIFI_INTMODE_RUN_BH_ONCE;
}
}
/* Add the new station to the station record data base */
-static int peer_add_new_record(unifi_priv_t *priv,CsrWifiRouterCtrlPeerAddReq *req,CsrUint32 *handle)
+static int peer_add_new_record(unifi_priv_t *priv,CsrWifiRouterCtrlPeerAddReq *req,u32 *handle)
{
u8 i, powerModeTemp = 0;
CsrBool freeSlotFound = FALSE;
CsrWifiRouterCtrlPeerAddReq* req = (CsrWifiRouterCtrlPeerAddReq*)msg;
CsrResult status = CSR_RESULT_SUCCESS;
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
- CsrUint32 handle = 0;
+ u32 handle = 0;
netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
unifi_trace(priv, UDBG2, "entering CsrWifiRouterCtrlPeerAddReqHandler \n");
*/
void
unifi_ta_indicate_l4stats(void *ospriv,
- CsrUint32 rxTcpThroughput,
- CsrUint32 txTcpThroughput,
- CsrUint32 rxUdpThroughput,
- CsrUint32 txUdpThroughput)
+ u32 rxTcpThroughput,
+ u32 txTcpThroughput,
+ u32 rxUdpThroughput,
+ u32 txUdpThroughput)
{
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
void *dst, int param_max_len)
{
u8 int_str[7] = "0";
- CsrUint32 param_str_len;
+ u32 param_str_len;
u8 *param_str_begin,*param_str_end;
u8 *orig_str = *str_ptr;
switch (param_type) {
case PARAM_TYPE_INT:
{
- CsrUint32 *pdst_int = dst,num =0;
+ u32 *pdst_int = dst,num =0;
int i,j=0;
if (param_str_len > sizeof(int_str)) {
param_str_len = sizeof(int_str);
*/
void
logging_handler(void *ospriv,
- u8 *sigdata, CsrUint32 signal_len,
+ u8 *sigdata, u32 signal_len,
const bulk_data_param_t *bulkdata,
enum udi_log_direction direction)
{
* The following complex casting is in place in order to eliminate 64-bit compilation warning
* "cast to/from pointer from/to integer of different size"
*/
- CsrUint32 align_offset = (CsrUint32)(long)(bulkdata->d[i].os_data_ptr) & (CSR_WIFI_ALIGN_BYTES-1);
+ u32 align_offset = (u32)(long)(bulkdata->d[i].os_data_ptr) & (CSR_WIFI_ALIGN_BYTES-1);
if (align_offset)
{
skb = (struct sk_buff*)bulkdata->d[i].os_net_buf_ptr;
int dir);
void logging_handler(void *ospriv,
- u8 *sigdata, CsrUint32 signal_len,
+ u8 *sigdata, u32 signal_len,
const bulk_data_param_t *bulkdata,
enum udi_log_direction direction);
*/
static void
unifi_process_receive_event(void *ospriv,
- u8 *sigdata, CsrUint32 siglen,
+ u8 *sigdata, u32 siglen,
const bulk_data_param_t *bulkdata)
{
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
*/
void
unifi_receive_event(void *ospriv,
- u8 *sigdata, CsrUint32 siglen,
+ u8 *sigdata, u32 siglen,
const bulk_data_param_t *bulkdata)
{
#ifdef CSR_WIFI_RX_PATH_SPLIT
tx_buffered_packets_t* buffered_pkt)
{
struct sk_buff *skb ;
- CsrUint32 align_offset;
+ u32 align_offset;
if (priv == NULL || bulkdata == NULL || buffered_pkt == NULL){
return;
}
skb = (struct sk_buff*)bulkdata->d[0].os_net_buf_ptr;
- align_offset = (CsrUint32)(long)(bulkdata->d[0].os_data_ptr) & (CSR_WIFI_ALIGN_BYTES-1);
+ align_offset = (u32)(long)(bulkdata->d[0].os_data_ptr) & (CSR_WIFI_ALIGN_BYTES-1);
if(align_offset){
skb_pull(skb,align_offset);
}
}
#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
-CsrResult unifi_reque_ma_packet_request (void *ospriv, CsrUint32 host_tag,
+CsrResult unifi_reque_ma_packet_request (void *ospriv, u32 host_tag,
u16 txStatus, bulk_data_desc_t *bulkDataDesc)
{
CsrResult status = CSR_RESULT_SUCCESS;
*
* ---------------------------------------------------------------------------
*/
-void update_tim(unifi_priv_t * priv, u16 aid, u8 setTim, u16 interfaceTag, CsrUint32 handle)
+void update_tim(unifi_priv_t * priv, u16 aid, u8 setTim, u16 interfaceTag, u32 handle)
{
CSR_SIGNAL signal;
CsrInt32 r;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
u8 senderIdLsb = 0;
CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
- CsrUint32 oldTimSetStatus = 0, timSetStatus = 0;
+ u32 oldTimSetStatus = 0, timSetStatus = 0;
unifi_trace(priv, UDBG5, "entering the update_tim routine\n");
CsrWifiPacketType pktType;
int frameType = 0;
CsrBool queuePacketDozing = FALSE;
- CsrUint32 priority_q;
+ u32 priority_q;
u16 frmCtrl;
struct list_head * list = NULL; /* List to which buffered PDUs are to be enqueued*/
CsrBool setBcTim=FALSE;
netInterface_priv_t *interfacePriv;
CsrBool requeueOnSamePos = FALSE;
- CsrUint32 handle = 0xFFFFFFFF;
+ u32 handle = 0xFFFFFFFF;
unsigned long lock_flags;
unifi_trace(priv, UDBG5,
u8 pduSent =0;
unsigned long lock_flags;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
- CsrUint32 hostTag = 0xffffffff;
+ u32 hostTag = 0xffffffff;
func_enter();
if(!isRouterBufferEnabled(priv,UNIFI_TRAFFIC_Q_VO)) {
}
#endif
void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata,
- CsrUint32 siglen)
+ u32 siglen)
{
#ifdef CSR_SUPPORT_SME
CSR_SIGNAL signal;
void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue q)
{
u16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
- CsrUint32 startIndex=0,endIndex=0;
+ u32 startIndex=0,endIndex=0;
CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
u8 queue;
CsrBool moreData = FALSE;
CSR_TRANSMISSION_CONTROL transmissionControl = (TRANSMISSION_CONTROL_EOSP_MASK | TRANSMISSION_CONTROL_TRIGGER_MASK);
int r;
CSR_SIGNAL signal;
- CsrUint32 priority_q;
+ u32 priority_q;
CSR_RATE transmitRate = 0;
CSR_TRANSMISSION_CONTROL transmissionControl = 0;
int r;
CSR_SIGNAL signal;
- CsrUint32 priority_q;
+ u32 priority_q;
CSR_RATE transmitRate = 0;
CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
unsigned long lock_flags;
}
/* generic function to get the station record handler from the handle */
CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_priv_t *priv,
- CsrUint32 handle,
+ u32 handle,
u16 interfaceTag)
{
netInterface_priv_t *interfacePriv;
/* Function to do inactivity */
void uf_check_inactivity(unifi_priv_t *priv, u16 interfaceTag, CsrTime currentTime)
{
- CsrUint32 i;
+ u32 i;
CsrWifiRouterCtrlStaInfo_t *staInfo;
CsrTime elapsedTime; /* Time in microseconds */
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
elapsedTime = (currentTime >= staInfo->lastActivity)?
(currentTime - staInfo->lastActivity):
- (~((CsrUint32)0) - staInfo->lastActivity + currentTime);
+ (~((u32)0) - staInfo->lastActivity + currentTime);
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
if (elapsedTime > MAX_INACTIVITY_INTERVAL) {
* 64 bit handling */
elapsedTime = (currentTime >= interfacePriv->last_inactivity_check)?
(currentTime - interfacePriv->last_inactivity_check):
- (~((CsrUint32)0) - interfacePriv->last_inactivity_check + currentTime);
+ (~((u32)0) - interfacePriv->last_inactivity_check + currentTime);
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
/* Sme sends these parameters */
CsrWifiMacAddress peerMacAddress;
- CsrUint32 assignedHandle;
+ u32 assignedHandle;
CsrBool wmmOrQosEnabled;
CsrWifiAcPowersaveMode powersaveMode[MAX_ACCESS_CATOGORY];
u16 maxSpLength;
#endif
- CsrUint32 rxTcpThroughput;
- CsrUint32 txTcpThroughput;
- CsrUint32 rxUdpThroughput;
- CsrUint32 txUdpThroughput;
+ u32 rxTcpThroughput;
+ u32 txTcpThroughput;
+ u32 rxUdpThroughput;
+ u32 txUdpThroughput;
#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
/*Set if multicast KeyID = 1*/
u8 mc_list[UNIFI_MAX_MULTICAST_ADDRESSES*ETH_ALEN];
/* The multicast addresses count that the thread needs to set. */
int mc_list_count;
- CsrUint32 tag;
+ u32 tag;
#ifdef CSR_SUPPORT_SME
/* (un)controlled port configuration */
unifi_port_config_t controlled_data_port;
CSR_CLIENT_TAG m4_hostTag;
CsrBool dtimActive;
CsrBool intraBssEnabled;
- CsrUint32 multicastPduHostTag; /* Used to set the tim after getting
+ u32 multicastPduHostTag; /* Used to set the tim after getting
a confirm for it */
CsrBool bcTimSet;
CsrBool bcTimSetReqPendingFlag;
#endif
CsrResult uf_process_ma_packet_req(unifi_priv_t *priv, u8 *peerMacAddress, CSR_CLIENT_TAG hostTag, u16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl, CSR_RATE TransmitRate, CSR_PRIORITY priority, CSR_PROCESS_ID senderId, bulk_data_param_t *bulkdata);
-void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata, CsrUint32 siglen);
+void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata, u32 siglen);
#ifdef CSR_SUPPORT_SME
void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue queue);
int uf_process_station_records_for_sending_data(unifi_priv_t *priv,u16 interfaceTag,
/* handle is 6 bits to accomodate in senderId LSB (only 64 station can be associated) */
#define CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE 0x3F
-void update_tim(unifi_priv_t * priv, u16 aid, u8 setTim, u16 interfaceTag, CsrUint32 handle);
+void update_tim(unifi_priv_t * priv, u16 aid, u8 setTim, u16 interfaceTag, u32 handle);
void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, u16 senderProcessId);
/* Clear the Peer station Record, in case of wifioff/unexpected card removal */
/* Fetch the station record handler from data base for matching handle */
CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_priv_t *priv,
- CsrUint32 handle,
+ u32 handle,
u16 interfaceTag);
void uf_update_sta_activity(unifi_priv_t *priv, u16 interfaceTag, const u8 *peerMacAddress);
int unifi_cfg_wmm_addts(unifi_priv_t *priv, unsigned char *arg)
{
- CsrUint32 addts_tid;
+ u32 addts_tid;
u8 addts_ie_length;
u8 *addts_ie;
u8 *addts_params;
int rc;
addts_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
- if (get_user(addts_tid, (CsrUint32*)addts_params)) {
+ if (get_user(addts_tid, (u32*)addts_params)) {
unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n");
return -EFAULT;
}
- addts_params += sizeof(CsrUint32);
+ addts_params += sizeof(u32);
if (get_user(addts_ie_length, (u8*)addts_params)) {
unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n");
return -EFAULT;
int unifi_cfg_wmm_delts(unifi_priv_t *priv, unsigned char *arg)
{
- CsrUint32 delts_tid;
+ u32 delts_tid;
u8 *delts_params;
CsrWifiSmeDataBlock tspec;
CsrWifiSmeDataBlock tclas;
int rc;
delts_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
- if (get_user(delts_tid, (CsrUint32*)delts_params)) {
+ if (get_user(delts_tid, (u32*)delts_params)) {
unifi_error(priv, "unifi_cfg_wmm_delts: Failed to get the argument\n");
return -EFAULT;
}
u16 interfaceTag = interfacePriv->InterfaceTag;
unifi_priv_t *priv = interfacePriv->privPtr;
- CsrUint32 pktBulkDataLength;
+ u32 pktBulkDataLength;
u8 *pktBulkData;
unsigned long flags;
int sme_mgt_coex_info_get(unifi_priv_t *priv, CsrWifiSmeCoexInfo *coexInfo);
int sme_mgt_packet_filter_set(unifi_priv_t *priv);
int sme_mgt_tspec(unifi_priv_t *priv, CsrWifiSmeListAction action,
- CsrUint32 tid, CsrWifiSmeDataBlock *tspec, CsrWifiSmeDataBlock *tclas);
+ u32 tid, CsrWifiSmeDataBlock *tspec, CsrWifiSmeDataBlock *tclas);
#ifdef CSR_SUPPORT_WEXT
/*
projects / platform / kernel / linux-3.10.git / commitdiff