Use the in-kernel u16 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>
* void
*
*----------------------------------------------------------------------------*/
-void CsrThreadSleep(CsrUint16 sleepTimeInMs)
+void CsrThreadSleep(u16 sleepTimeInMs)
{
unsigned long t;
#define CSR_FE_RESULT_NO_MORE_THREADS ((CsrResult) 0x0006)
/* Thread priorities */
-#define CSR_THREAD_PRIORITY_HIGHEST ((CsrUint16) 0)
-#define CSR_THREAD_PRIORITY_HIGH ((CsrUint16) 1)
-#define CSR_THREAD_PRIORITY_NORMAL ((CsrUint16) 2)
-#define CSR_THREAD_PRIORITY_LOW ((CsrUint16) 3)
-#define CSR_THREAD_PRIORITY_LOWEST ((CsrUint16) 4)
+#define CSR_THREAD_PRIORITY_HIGHEST ((u16) 0)
+#define CSR_THREAD_PRIORITY_HIGH ((u16) 1)
+#define CSR_THREAD_PRIORITY_NORMAL ((u16) 2)
+#define CSR_THREAD_PRIORITY_LOW ((u16) 3)
+#define CSR_THREAD_PRIORITY_LOWEST ((u16) 4)
-#define CSR_EVENT_WAIT_INFINITE ((CsrUint16) 0xFFFF)
+#define CSR_EVENT_WAIT_INFINITE ((u16) 0xFFFF)
/*----------------------------------------------------------------------------*
* NAME
* CSR_FE_RESULT_INVALID_POINTER in case the eventBits pointer is invalid
*
*----------------------------------------------------------------------------*/
-CsrResult CsrEventWait(CsrEventHandle *eventHandle, CsrUint16 timeoutInMs, CsrUint32 *eventBits);
+CsrResult CsrEventWait(CsrEventHandle *eventHandle, u16 timeoutInMs, CsrUint32 *eventBits);
/*----------------------------------------------------------------------------*
* NAME
*
*----------------------------------------------------------------------------*/
CsrResult CsrThreadCreate(void (*threadFunction)(void *pointer), void *pointer,
- CsrUint32 stackSize, CsrUint16 priority,
+ CsrUint32 stackSize, u16 priority,
const CsrCharString *threadName, CsrThreadHandle *threadHandle);
/*----------------------------------------------------------------------------*
* void
*
*----------------------------------------------------------------------------*/
-void CsrThreadSleep(CsrUint16 sleepTimeInMs);
+void CsrThreadSleep(u16 sleepTimeInMs);
#ifndef CSR_PMEM_DEBUG_ENABLE
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrEvent
*
*----------------------------------------------------------------------------*/
-CsrEvent *CsrEvent_struct(CsrUint16 primtype, CsrUint16 msgtype);
+CsrEvent *CsrEvent_struct(u16 primtype, u16 msgtype);
typedef struct
{
* Allocates and fills in a message with the signature CsrEventCsrUint8
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint8 *CsrEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, u8 value);
+CsrEventCsrUint8 *CsrEventCsrUint8_struct(u16 primtype, u16 msgtype, u8 value);
typedef struct
{
CsrPrim type;
- CsrUint16 value;
+ u16 value;
} CsrEventCsrUint16;
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrEventCsrUint16
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint16 *CsrEventCsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value);
+CsrEventCsrUint16 *CsrEventCsrUint16_struct(u16 primtype, u16 msgtype, u16 value);
typedef struct
{
CsrPrim type;
- CsrUint16 value1;
+ u16 value1;
u8 value2;
} CsrEventCsrUint16CsrUint8;
* Allocates and fills in a message with the signature CsrEventCsrUint16CsrUint8
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrUint8 *CsrEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, u8 value2);
+CsrEventCsrUint16CsrUint8 *CsrEventCsrUint16CsrUint8_struct(u16 primtype, u16 msgtype, u16 value1, u8 value2);
typedef struct
{
CsrPrim type;
- CsrUint16 value1;
- CsrUint16 value2;
+ u16 value1;
+ u16 value2;
} CsrEventCsrUint16CsrUint16;
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrEventCsrUint16CsrUint16
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrUint16 *CsrEventCsrUint16CsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrUint16 value2);
+CsrEventCsrUint16CsrUint16 *CsrEventCsrUint16CsrUint16_struct(u16 primtype, u16 msgtype, u16 value1, u16 value2);
typedef struct
{
CsrPrim type;
- CsrUint16 value1;
+ u16 value1;
CsrUint32 value2;
} CsrEventCsrUint16CsrUint32;
* Allocates and fills in a message with the signature CsrEventCsrUint16
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrUint32 *CsrEventCsrUint16CsrUint32_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrUint32 value2);
+CsrEventCsrUint16CsrUint32 *CsrEventCsrUint16CsrUint32_struct(u16 primtype, u16 msgtype, u16 value1, CsrUint32 value2);
typedef struct
{
CsrPrim type;
- CsrUint16 value1;
+ u16 value1;
CsrCharString *value2;
} CsrEventCsrUint16CsrCharString;
* Allocates and fills in a message with the signature CsrEventCsrUint16CsrCharString
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrCharString *CsrEventCsrUint16CsrCharString_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrCharString *value2);
+CsrEventCsrUint16CsrCharString *CsrEventCsrUint16CsrCharString_struct(u16 primtype, u16 msgtype, u16 value1, CsrCharString *value2);
typedef struct
{
* Allocates and fills in a message with the signature CsrEventCsrUint32
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint32 *CsrEventCsrUint32_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint32 value);
+CsrEventCsrUint32 *CsrEventCsrUint32_struct(u16 primtype, u16 msgtype, CsrUint32 value);
typedef struct
{
CsrPrim type;
CsrUint32 value1;
- CsrUint16 value2;
+ u16 value2;
} CsrEventCsrUint32CsrUint16;
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrEventCsrUint32CsrUint16
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint32CsrUint16 *CsrEventCsrUint32CsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint32 value1, CsrUint32 value2);
+CsrEventCsrUint32CsrUint16 *CsrEventCsrUint32CsrUint16_struct(u16 primtype, u16 msgtype, CsrUint32 value1, CsrUint32 value2);
typedef struct
{
* Allocates and fills in a message with the signature CsrEventCsrUint32CsrCharString
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint32CsrCharString *CsrEventCsrUint32CsrCharString_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint32 value1, CsrCharString *value2);
+CsrEventCsrUint32CsrCharString *CsrEventCsrUint32CsrCharString_struct(u16 primtype, u16 msgtype, CsrUint32 value1, CsrCharString *value2);
#ifdef __cplusplus
}
typedef struct
{
- CsrUint16 primitiveType;
+ u16 primitiveType;
const CsrCharString *primitiveName;
CsrMsgConvMsgEntry *messageConv; /* Private - do not use */
} CsrLogPrimitiveInformation;
/* Tech logging */
/*---------------------------------*/
typedef u8 bitmask8_t;
-typedef CsrUint16 bitmask16_t;
+typedef u16 bitmask16_t;
typedef CsrUint32 bitmask32_t;
#ifdef CSR_LOG_ENABLE
void CsrLogSchedStop(u8 thread_id);
void CsrLogInitTask(u8 thread_id, CsrSchedQid tskid, const CsrCharString *tskName);
-void CsrLogDeinitTask(CsrUint16 task_id);
+void CsrLogDeinitTask(u16 task_id);
void CsrLogActivate(CsrSchedQid tskid);
void CsrLogDeactivate(CsrSchedQid tskid);
CsrSchedQid src_task_id,
CsrSchedQid dst_taskid,
CsrSchedMsgId msg_id,
- CsrUint16 prim_type,
+ u16 prim_type,
const void *msg);
void CsrLogMessageGet(CsrSchedQid src_task_id,
CsrSchedQid dst_taskid,
CsrBool get_res,
CsrSchedMsgId msg_id,
- CsrUint16 prim_type,
+ u16 prim_type,
const void *msg);
void CsrLogTimedEventIn(CsrUint32 line,
CsrSchedQid task_id,
CsrSchedTid tid,
CsrTime requested_delay,
- CsrUint16 fniarg,
+ u16 fniarg,
const void *fnvarg);
void CsrLogTimedEventFire(CsrSchedQid task_id,
void CsrLogBgintServiceStart(CsrSchedBgint irq);
void CsrLogBgintServiceDone(CsrSchedBgint irq);
-void CsrLogExceptionStateEvent(CsrUint16 prim_type,
+void CsrLogExceptionStateEvent(u16 prim_type,
CsrPrim msg_type,
- CsrUint16 state,
+ u16 state,
CsrUint32 line,
const CsrCharString *file);
-void CsrLogExceptionGeneral(CsrUint16 prim_type,
- CsrUint16 state,
+void CsrLogExceptionGeneral(u16 prim_type,
+ u16 state,
const CsrCharString *text,
CsrUint32 line,
const CsrCharString *file);
-void CsrLogExceptionWarning(CsrUint16 prim_type,
- CsrUint16 state,
+void CsrLogExceptionWarning(u16 prim_type,
+ u16 state,
const CsrCharString *text,
CsrUint32 line,
const CsrCharString *file);
#define CSR_LOG_LEVEL_TEXT_ALL ((CsrLogLevelText) 0xFFFF)
/* The log text interface is used by both scheduler tasks and components outside the scheduler context.
- * Therefore a CsrLogTextTaskId is introduced. It is effectively considered as two CsrUint16's. The lower
+ * Therefore a CsrLogTextTaskId is introduced. It is effectively considered as two u16's. The lower
* 16 bits corresponds one2one with the scheduler queueId's (CsrSchedQid) and as such these bits can not be used
* by components outside scheduler tasks. The upper 16 bits are allocated for use of components outside the
* scheduler like drivers etc. Components in this range is defined independently by each technology. To avoid
/* Set the text logging level for a given tasks subOrigin */
/* This function can be used as a complement to CsrLogLevelTextSetAll() and CsrLogLevelTextSetTask() to add more _or_ less log from a given
* subOrigin within a task than what is set generally with CsrLogLevelTextSetAll() _or_ CsrLogLevelTextSetTask(). */
-void CsrLogLevelTextSetTaskSubOrigin(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrLogLevelText warningLevelMask);
+void CsrLogLevelTextSetTaskSubOrigin(CsrLogTextTaskId taskId, u16 subOrigin, CsrLogLevelText warningLevelMask);
/*******************************************************************************
typedef struct CsrLogSubOrigin
{
- CsrUint16 subOriginNumber; /* Id of the given SubOrigin */
+ u16 subOriginNumber; /* Id of the given SubOrigin */
const CsrCharString *subOriginName; /* Prefix Text for this SubOrigin */
} CsrLogSubOrigin;
/* Register a task which is going to use the CSR_LOG_TEXT_XXX interface */
#ifdef CSR_LOG_ENABLE
-void CsrLogTextRegister(CsrLogTextTaskId taskId, const CsrCharString *taskName, CsrUint16 subOriginsLength, const CsrLogSubOrigin *subOrigins);
+void CsrLogTextRegister(CsrLogTextTaskId taskId, const CsrCharString *taskName, u16 subOriginsLength, const CsrLogSubOrigin *subOrigins);
#else
#define CsrLogTextRegister(taskId, taskName, subOriginsLength, subOrigins)
#endif
/* CRITICAL: Conditions that are threatening to the integrity/stability of the
system as a whole. */
#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_CRITICAL_DISABLE)
-void CsrLogTextCritical(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextCritical(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
#define CSR_LOG_TEXT_CRITICAL(taskId_subOrigin_formatString_varargs) CsrLogTextCritical taskId_subOrigin_formatString_varargs
#define CSR_LOG_TEXT_CONDITIONAL_CRITICAL(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_CRITICAL(logtextargs);}}
#define CSR_LOG_TEXT_BUFFER_CRITICAL(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferCritical taskId_subOrigin_length_buffer_formatString_varargs
/* ERROR: Malfunction of a component rendering it unable to operate correctly,
causing lack of functionality but not loss of system integrity/stability. */
#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_ERROR_DISABLE)
-void CsrLogTextError(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferError(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextError(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
#define CSR_LOG_TEXT_ERROR(taskId_subOrigin_formatString_varargs) CsrLogTextError taskId_subOrigin_formatString_varargs
#define CSR_LOG_TEXT_CONDITIONAL_ERROR(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_ERROR(logtextargs);}}
#define CSR_LOG_TEXT_BUFFER_ERROR(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferError taskId_subOrigin_length_buffer_formatString_varargs
or violations of specifications, where the result of such deviations does not
lead to malfunction of the component. */
#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_WARNING_DISABLE)
-void CsrLogTextWarning(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextWarning(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
#define CSR_LOG_TEXT_WARNING(taskId_subOrigin_formatString_varargs) CsrLogTextWarning taskId_subOrigin_formatString_varargs
#define CSR_LOG_TEXT_CONDITIONAL_WARNING(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_WARNING(logtextargs);}}
#define CSR_LOG_TEXT_BUFFER_WARNING(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferWarning taskId_subOrigin_length_buffer_formatString_varargs
/* INFO: Important events that may aid in determining the conditions under which
the more severe conditions are encountered. */
#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_INFO_DISABLE)
-void CsrLogTextInfo(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextInfo(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
#define CSR_LOG_TEXT_INFO(taskId_subOrigin_formatString_varargs) CsrLogTextInfo taskId_subOrigin_formatString_varargs
#define CSR_LOG_TEXT_CONDITIONAL_INFO(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_INFO(logtextargs);}}
#define CSR_LOG_TEXT_BUFFER_INFO(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferInfo taskId_subOrigin_length_buffer_formatString_varargs
/* DEBUG: Similar to INFO, but dedicated to events that occur more frequently. */
#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_DEBUG_DISABLE)
-void CsrLogTextDebug(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextDebug(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
#define CSR_LOG_TEXT_DEBUG(taskId_subOrigin_formatString_varargs) CsrLogTextDebug taskId_subOrigin_formatString_varargs
#define CSR_LOG_TEXT_CONDITIONAL_DEBUG(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_DEBUG(logtextargs);}}
#define CSR_LOG_TEXT_BUFFER_DEBUG(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferDebug taskId_subOrigin_length_buffer_formatString_varargs
/*------------------------------------------------------------------*/
/* Endian conversion */
/*------------------------------------------------------------------*/
-#define CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr) (((CsrUint16) ((u8 *) (ptr))[0]) | ((CsrUint16) ((u8 *) (ptr))[1]) << 8)
+#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_COPY_UINT16_TO_LITTLE_ENDIAN(uint, ptr) ((u8 *) (ptr))[0] = ((u8) ((uint) & 0x00FF)); \
((u8 *) (ptr))[1] = ((u8) (((uint) >> 8) & 0x000000FF)); \
((u8 *) (ptr))[2] = ((u8) (((uint) >> 16) & 0x000000FF)); \
((u8 *) (ptr))[3] = ((u8) (((uint) >> 24) & 0x000000FF))
-#define CSR_GET_UINT16_FROM_BIG_ENDIAN(ptr) (((CsrUint16) ((u8 *) (ptr))[1]) | ((CsrUint16) ((u8 *) (ptr))[0]) << 8)
+#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 | \
(output) = ((u8) (input));(input) += 2
#define CSR_CONVERT_16_FROM_XAP(output, input) \
- (output) = (CsrUint16) ((((CsrUint16) (input)[1]) << 8) | \
- ((CsrUint16) (input)[0]));(input) += 2
+ (output) = (u16) ((((u16) (input)[1]) << 8) | \
+ ((u16) (input)[0]));(input) += 2
#define CSR_CONVERT_32_FROM_XAP(output, input) \
(output) = (((CsrUint32) (input)[1]) << 24) | \
static CsrMsgConvEntry *converter;
-CsrMsgConvPrimEntry *CsrMsgConvFind(CsrUint16 primType)
+CsrMsgConvPrimEntry *CsrMsgConvFind(u16 primType)
{
CsrMsgConvPrimEntry *ptr = NULL;
return ptr;
}
-static const CsrMsgConvMsgEntry *find_msg_converter(CsrMsgConvPrimEntry *ptr, CsrUint16 msgType)
+static const CsrMsgConvMsgEntry *find_msg_converter(CsrMsgConvPrimEntry *ptr, u16 msgType)
{
const CsrMsgConvMsgEntry *cv = ptr->conv;
if (ptr->lookupFunc)
return cv;
}
-static void *deserialize_data(CsrUint16 primType,
+static void *deserialize_data(u16 primType,
CsrSize length,
u8 *data)
{
if (ptr)
{
const CsrMsgConvMsgEntry *cv;
- CsrUint16 msgId = 0;
+ u16 msgId = 0;
CsrSize offset = 0;
CsrUint16Des(&msgId, data, &offset);
return ret;
}
-static CsrSize sizeof_message(CsrUint16 primType, void *msg)
+static CsrSize sizeof_message(u16 primType, void *msg)
{
CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
CsrSize ret;
if (ptr)
{
const CsrMsgConvMsgEntry *cv;
- CsrUint16 msgId = *(CsrUint16 *) msg;
+ u16 msgId = *(u16 *) msg;
cv = find_msg_converter(ptr, msgId);
if (cv)
return ret;
}
-static CsrBool free_message(CsrUint16 primType, u8 *data)
+static CsrBool free_message(u16 primType, u8 *data)
{
CsrMsgConvPrimEntry *ptr;
CsrBool ret;
if (ptr)
{
const CsrMsgConvMsgEntry *cv;
- CsrUint16 msgId = *(CsrUint16 *) data;
+ u16 msgId = *(u16 *) data;
cv = find_msg_converter(ptr, msgId);
if (cv)
return ret;
}
-static u8 *serialize_message(CsrUint16 primType,
+static u8 *serialize_message(u16 primType,
void *msg,
CsrSize *length,
u8 *buffer)
{
const CsrMsgConvMsgEntry *cv;
- cv = find_msg_converter(ptr, *(CsrUint16 *) msg);
+ cv = find_msg_converter(ptr, *(u16 *) msg);
if (cv)
{
ret = cv->serFunc(buffer, length, msg);
return ret;
}
-CsrSize CsrMsgConvSizeof(CsrUint16 primType, void *msg)
+CsrSize CsrMsgConvSizeof(u16 primType, void *msg)
{
return sizeof_message(primType, msg);
}
-u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg)
+u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, u16 primType, void *msg)
{
if (converter)
{
}
/* Insert profile converter at head of converter list. */
-void CsrMsgConvInsert(CsrUint16 primType, const CsrMsgConvMsgEntry *ce)
+void CsrMsgConvInsert(u16 primType, const CsrMsgConvMsgEntry *ce)
{
CsrMsgConvPrimEntry *pc;
pc = CsrMsgConvFind(primType);
}
EXPORT_SYMBOL_GPL(CsrMsgConvInsert);
-CsrMsgConvMsgEntry *CsrMsgConvFindEntry(CsrUint16 primType, CsrUint16 msgType)
+CsrMsgConvMsgEntry *CsrMsgConvFindEntry(u16 primType, u16 msgType)
{
CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
if (ptr)
}
EXPORT_SYMBOL_GPL(CsrMsgConvFindEntry);
-CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(CsrUint16 primType, const void *msg)
+CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(u16 primType, const void *msg)
{
CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
if (ptr && msg)
{
- CsrUint16 msgType = *((CsrUint16 *) msg);
+ u16 msgType = *((u16 *) msg);
return (CsrMsgConvMsgEntry *) find_msg_converter(ptr, msgType);
}
return NULL;
}
-void CsrMsgConvCustomLookupRegister(CsrUint16 primType, CsrMsgCustomLookupFunc *lookupFunc)
+void CsrMsgConvCustomLookupRegister(u16 primType, CsrMsgCustomLookupFunc *lookupFunc)
{
CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
if (ptr)
/* Converter entry for one message type */
typedef struct CsrMsgConvMsgEntry
{
- CsrUint16 msgType;
+ u16 msgType;
CsrMsgSizeofFunc *sizeofFunc;
CsrMsgSerializeFunc *serFunc;
CsrMsgDeserializeFunc *deserFunc;
} CsrMsgConvMsgEntry;
/* Optional lookup function */
-typedef CsrMsgConvMsgEntry *(CsrMsgCustomLookupFunc)(CsrMsgConvMsgEntry *ce, CsrUint16 msgType);
+typedef CsrMsgConvMsgEntry *(CsrMsgCustomLookupFunc)(CsrMsgConvMsgEntry *ce, u16 msgType);
/* All converter entries for one specific primitive */
typedef struct CsrMsgConvPrimEntry
{
- CsrUint16 primType;
+ u16 primType;
const CsrMsgConvMsgEntry *conv;
CsrMsgCustomLookupFunc *lookupFunc;
struct CsrMsgConvPrimEntry *next;
typedef struct
{
CsrMsgConvPrimEntry *profile_converters;
- void *(*deserialize_data)(CsrUint16 primType, CsrSize length, u8 * data);
- CsrBool (*free_message)(CsrUint16 primType, u8 *data);
- CsrSize (*sizeof_message)(CsrUint16 primType, void *msg);
- u8 *(*serialize_message)(CsrUint16 primType, void *msg,
+ void *(*deserialize_data)(u16 primType, CsrSize length, u8 * data);
+ CsrBool (*free_message)(u16 primType, u8 *data);
+ CsrSize (*sizeof_message)(u16 primType, void *msg);
+ u8 *(*serialize_message)(u16 primType, void *msg,
CsrSize * length,
u8 * buffer);
} CsrMsgConvEntry;
-CsrSize CsrMsgConvSizeof(CsrUint16 primType, void *msg);
-u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg);
-void CsrMsgConvCustomLookupRegister(CsrUint16 primType, CsrMsgCustomLookupFunc *lookupFunc);
-void CsrMsgConvInsert(CsrUint16 primType, const CsrMsgConvMsgEntry *ce);
-CsrMsgConvPrimEntry *CsrMsgConvFind(CsrUint16 primType);
-CsrMsgConvMsgEntry *CsrMsgConvFindEntry(CsrUint16 primType, CsrUint16 msgType);
-CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(CsrUint16 primType, const void *msg);
+CsrSize CsrMsgConvSizeof(u16 primType, void *msg);
+u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, u16 primType, void *msg);
+void CsrMsgConvCustomLookupRegister(u16 primType, CsrMsgCustomLookupFunc *lookupFunc);
+void CsrMsgConvInsert(u16 primType, const CsrMsgConvMsgEntry *ce);
+CsrMsgConvPrimEntry *CsrMsgConvFind(u16 primType);
+CsrMsgConvMsgEntry *CsrMsgConvFindEntry(u16 primType, u16 msgType);
+CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(u16 primType, const void *msg);
CsrMsgConvEntry *CsrMsgConvGet(void);
CsrMsgConvEntry *CsrMsgConvInit(void);
#ifdef ENABLE_SHUTDOWN
/* Prototypes for primitive type serializers */
void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value);
-void CsrUint16Ser(u8 *buffer, CsrSize *offset, CsrUint16 value);
+void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value);
void CsrUint32Ser(u8 *buffer, CsrSize *offset, CsrUint32 value);
void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length);
void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value);
void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value);
void CsrUint8Des(u8 *value, u8 *buffer, CsrSize *offset);
-void CsrUint16Des(CsrUint16 *value, u8 *buffer, CsrSize *offset);
+void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset);
void CsrUint32Des(CsrUint32 *value, u8 *buffer, CsrSize *offset);
void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length);
void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset);
#include "csr_types.h"
#include "csr_panic.h"
-void CsrPanic(u8 tech, CsrUint16 reason, const char *p)
+void CsrPanic(u8 tech, u16 reason, const char *p)
{
BUG_ON(1);
}
/* Panic interface used by technologies */
/* DEPRECATED - replaced by csr_log_text.h */
-void CsrPanic(u8 tech, CsrUint16 reason, const char *p);
+void CsrPanic(u8 tech, u16 reason, const char *p);
#ifdef __cplusplus
}
/************************************************************************************
* Segmentation of primitives in upstream and downstream segment
************************************************************************************/
-typedef CsrUint16 CsrPrim;
+typedef u16 CsrPrim;
#define CSR_PRIM_UPSTREAM ((CsrPrim) (0x8000))
/************************************************************************************
* Primitive definitions for Synergy framework
************************************************************************************/
-#define CSR_SYNERGY_EVENT_CLASS_BASE ((CsrUint16) (0x0600))
+#define CSR_SYNERGY_EVENT_CLASS_BASE ((u16) (0x0600))
-#define CSR_HCI_PRIM ((CsrUint16) (0x0000 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_BCCMD_PRIM ((CsrUint16) (0x0001 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_HQ_PRIM ((CsrUint16) (0x0002 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_VM_PRIM ((CsrUint16) (0x0003 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_TM_BLUECORE_PRIM ((CsrUint16) (0x0004 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_FP_PRIM ((CsrUint16) (0x0005 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_IP_SOCKET_PRIM ((CsrUint16) (0x0006 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_IP_ETHER_PRIM ((CsrUint16) (0x0007 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_IP_IFCONFIG_PRIM ((CsrUint16) (0x0008 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_IP_INTERNAL_PRIM ((CsrUint16) (0x0009 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_FSAL_PRIM ((CsrUint16) (0x000A | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_DATA_STORE_PRIM ((CsrUint16) (0x000B | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_AM_PRIM ((CsrUint16) (0x000C | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_TLS_PRIM ((CsrUint16) (0x000D | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_DHCP_SERVER_PRIM ((CsrUint16) (0x000E | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_TFTP_PRIM ((CsrUint16) (0x000F | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_DSPM_PRIM ((CsrUint16) (0x0010 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_TLS_INTERNAL_PRIM ((CsrUint16) (0x0011 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_HCI_PRIM ((u16) (0x0000 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_BCCMD_PRIM ((u16) (0x0001 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_HQ_PRIM ((u16) (0x0002 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_VM_PRIM ((u16) (0x0003 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TM_BLUECORE_PRIM ((u16) (0x0004 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_FP_PRIM ((u16) (0x0005 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_SOCKET_PRIM ((u16) (0x0006 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_ETHER_PRIM ((u16) (0x0007 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_IFCONFIG_PRIM ((u16) (0x0008 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_INTERNAL_PRIM ((u16) (0x0009 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_FSAL_PRIM ((u16) (0x000A | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_DATA_STORE_PRIM ((u16) (0x000B | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_AM_PRIM ((u16) (0x000C | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TLS_PRIM ((u16) (0x000D | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_DHCP_SERVER_PRIM ((u16) (0x000E | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TFTP_PRIM ((u16) (0x000F | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_DSPM_PRIM ((u16) (0x0010 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TLS_INTERNAL_PRIM ((u16) (0x0011 | CSR_SYNERGY_EVENT_CLASS_BASE))
#define NUMBER_OF_CSR_FW_EVENTS (CSR_DSPM_PRIM - CSR_SYNERGY_EVENT_CLASS_BASE + 1)
-#define CSR_SYNERGY_EVENT_CLASS_MISC_BASE ((CsrUint16) (0x06A0))
+#define CSR_SYNERGY_EVENT_CLASS_MISC_BASE ((u16) (0x06A0))
-#define CSR_UI_PRIM ((CsrUint16) (0x0000 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
-#define CSR_APP_PRIM ((CsrUint16) (0x0001 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
-#define CSR_SDIO_PROBE_PRIM ((CsrUint16) (0x0002 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+#define CSR_UI_PRIM ((u16) (0x0000 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+#define CSR_APP_PRIM ((u16) (0x0001 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+#define CSR_SDIO_PROBE_PRIM ((u16) (0x0002 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
#define NUMBER_OF_CSR_FW_MISC_EVENTS (CSR_SDIO_PROBE_PRIM - CSR_SYNERGY_EVENT_CLASS_MISC_BASE + 1)
-#define CSR_ENV_PRIM ((CsrUint16) (0x00FF | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+#define CSR_ENV_PRIM ((u16) (0x00FF | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
#ifdef __cplusplus
}
extern "C" {
#endif
-typedef CsrUint16 CsrResult;
+typedef u16 CsrResult;
#define CSR_RESULT_SUCCESS ((CsrResult) 0x0000)
#define CSR_RESULT_FAILURE ((CsrResult) 0xFFFF)
typedef CsrUint32 CsrSchedIdentifier;
/* A task identifier */
-typedef CsrUint16 CsrSchedTaskId;
+typedef u16 CsrSchedTaskId;
/* A queue identifier */
-typedef CsrUint16 CsrSchedQid;
+typedef u16 CsrSchedQid;
#define CSR_SCHED_QID_INVALID ((CsrSchedQid) 0xFFFF)
/* A message identifier */
/*
* Background interrupt definitions
*/
-typedef CsrUint16 CsrSchedBgint;
+typedef u16 CsrSchedBgint;
#define CSR_SCHED_BGINT_INVALID ((CsrSchedBgint) 0xFFFF)
typedef void (*CsrSchedBgintHandler)(void *);
*----------------------------------------------------------------------------*/
#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
void CsrSchedMessagePutStringLog(CsrSchedQid q,
- CsrUint16 mi,
+ u16 mi,
void *mv,
CsrUint32 line,
const CsrCharString *file);
#define CsrSchedMessagePut(q, mi, mv) CsrSchedMessagePutStringLog((q), (mi), (mv), __LINE__, __FILE__)
#else
void CsrSchedMessagePut(CsrSchedQid q,
- CsrUint16 mi,
+ u16 mi,
void *mv);
#endif
*
*----------------------------------------------------------------------------*/
#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
-void CsrSchedMessageBroadcastStringLog(CsrUint16 mi,
+void CsrSchedMessageBroadcastStringLog(u16 mi,
void *(*msg_build_func)(void *),
void *msg_build_ptr,
CsrUint32 line,
const CsrCharString *file);
#define CsrSchedMessageBroadcast(mi, fn, ptr) CsrSchedMessageBroadcastStringLog((mi), (fn), (ptr), __LINE__, __FILE__)
#else
-void CsrSchedMessageBroadcast(CsrUint16 mi,
+void CsrSchedMessageBroadcast(u16 mi,
void *(*msg_build_func)(void *),
void *msg_build_ptr);
#endif
*
* DESCRIPTION
* Obtains a message from the message queue belonging to the calling task.
- * The message consists of one or both of a CsrUint16 and a void *.
+ * The message consists of one or both of a u16 and a void *.
*
* RETURNS
* CsrBool - TRUE if a message has been obtained from the queue, else FALSE.
* them message is discarded.
*
*----------------------------------------------------------------------------*/
-CsrBool CsrSchedMessageGet(CsrUint16 *pmi, void **pmv);
+CsrBool CsrSchedMessageGet(u16 *pmi, void **pmv);
/*----------------------------------------------------------------------------*
* NAME
*----------------------------------------------------------------------------*/
#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
CsrSchedTid CsrSchedTimerSetStringLog(CsrTime delay,
- void (*fn)(CsrUint16 mi, void *mv),
- CsrUint16 fniarg,
+ void (*fn)(u16 mi, void *mv),
+ u16 fniarg,
void *fnvarg,
CsrUint32 line,
const CsrCharString *file);
#define CsrSchedTimerSet(d, fn, fni, fnv) CsrSchedTimerSetStringLog((d), (fn), (fni), (fnv), __LINE__, __FILE__)
#else
CsrSchedTid CsrSchedTimerSet(CsrTime delay,
- void (*fn)(CsrUint16 mi, void *mv),
- CsrUint16 fniarg,
+ void (*fn)(u16 mi, void *mv),
+ u16 fniarg,
void *fnvarg);
#endif
*----------------------------------------------------------------------------*/
#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
CsrBool CsrSchedTimerCancelStringLog(CsrSchedTid eventid,
- CsrUint16 *pmi,
+ u16 *pmi,
void **pmv,
CsrUint32 line,
const CsrCharString *file);
#define CsrSchedTimerCancel(e, pmi, pmv) CsrSchedTimerCancelStringLog((e), (pmi), (pmv), __LINE__, __FILE__)
#else
CsrBool CsrSchedTimerCancel(CsrSchedTid eventid,
- CsrUint16 *pmi,
+ u16 *pmi,
void **pmv);
#endif
*----------------------------------------------------------------------------*/
typedef struct
{
- CsrUint16 manfId; /* Vendor ID to match or CSR_SDIO_ANY_MANF_ID */
- CsrUint16 cardId; /* Device ID to match or CSR_SDIO_ANY_CARD_ID */
+ u16 manfId; /* Vendor ID to match or CSR_SDIO_ANY_MANF_ID */
+ u16 cardId; /* Device ID to match or CSR_SDIO_ANY_CARD_ID */
u8 sdioFunction; /* SDIO Function number to match or CSR_SDIO_ANY_SDIO_FUNCTION */
u8 sdioInterface; /* SDIO Standard Interface Code to match or CSR_SDIO_ANY_SDIO_INTERFACE */
} CsrSdioFunctionId;
typedef struct
{
CsrSdioFunctionId sdioId;
- CsrUint16 blockSize; /* Actual configured block size, or 0 if unconfigured */
+ u16 blockSize; /* Actual configured block size, or 0 if unconfigured */
CsrUint32 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 */
* (after the second operation) is in the valid range.
*
*----------------------------------------------------------------------------*/
-CsrResult CsrSdioBlockSizeSet(CsrSdioFunction *function, CsrUint16 blockSize);
+CsrResult CsrSdioBlockSizeSet(CsrSdioFunction *function, u16 blockSize);
/*----------------------------------------------------------------------------*
* NAME
* the callback function.
*
*----------------------------------------------------------------------------*/
-CsrResult CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data);
-CsrResult CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data);
-void CsrSdioRead16Async(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data, CsrSdioAsyncCallback callback);
-void CsrSdioWrite16Async(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data, CsrSdioAsyncCallback callback);
+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);
/*----------------------------------------------------------------------------*
* NAME
}
EXPORT_SYMBOL_GPL(CsrUint8Des);
-void CsrUint16Des(CsrUint16 *value, u8 *buffer, CsrSize *offset)
+void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset)
{
*value = (buffer[*offset + 0] << 0) |
(buffer[*offset + 1] << 8);
}
EXPORT_SYMBOL_GPL(CsrUint8Ser);
-void CsrUint16Ser(u8 *buffer, CsrSize *offset, CsrUint16 value)
+void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value)
{
buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
for (i = 0; i < length; i++)
{
- CsrUint16Ser(buffer, offset, (CsrUint16) value[i]);
+ CsrUint16Ser(buffer, offset, (u16) value[i]);
}
}
else
typedef struct
{
CsrUint32 sec;
- CsrUint16 msec;
+ u16 msec;
} CsrTimeUtc;
typedef ptrdiff_t CsrIntptr; /* intptr_t is not defined in kernel. Use the equivalent ptrdiff_t. */
/* Unsigned fixed width types */
-typedef uint16_t CsrUint16;
typedef uint32_t CsrUint32;
/* Signed fixed width types */
/* String types */
typedef char CsrCharString;
typedef u8 CsrUtf8String;
-typedef CsrUint16 CsrUtf16String; /* 16-bit UTF16 strings */
+typedef u16 CsrUtf16String; /* 16-bit UTF16 strings */
typedef CsrUint32 CsrUint24;
/*
CsrUtf16String *CsrUtf16StrCpy(CsrUtf16String *target, const CsrUtf16String *source);
CsrUtf16String *CsrUtf16StringDuplicate(const CsrUtf16String *source);
-CsrUint16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2);
-CsrUint16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count);
+u16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2);
+u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count);
CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, CsrUint32 count);
CsrUtf16String *CsrUtf16ConcatenateTexts(const CsrUtf16String *inputText1, const CsrUtf16String *inputText2,
*********************************************************************************/
CsrUtf16String *CsrUint32ToUtf16String(CsrUint32 number)
{
- CsrUint16 count, noOfDigits;
+ u16 count, noOfDigits;
CsrUtf16String *output;
CsrUint32 tempNumber;
*********************************************************************************/
CsrUint32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString)
{
- CsrUint16 numLen, count;
+ u16 numLen, count;
CsrUint32 newNumber = 0;
- numLen = (CsrUint16) CsrUtf16StrLen(unicodeString);
+ numLen = (u16) CsrUtf16StrLen(unicodeString);
if ((numLen > 10) || (numLen == 0) || (unicodeString == NULL)) /*CSRMAX number is 4.294.967.295 */
{
ch -= offsetsFromUtf8[extraBytes2Read];
- if (ch <= 0xFFFF) /* Character can be encoded in one CsrUint16 */
+ if (ch <= 0xFFFF) /* Character can be encoded in one u16 */
{
- *dest++ = (CsrUint16) ch;
+ *dest++ = (u16) ch;
}
- else /* The character needs two CsrUint16 */
+ else /* The character needs two u16 */
{
ch -= UNI_HALF_BASE;
- *dest++ = (CsrUint16) ((ch >> UNI_HALF_SHIFT) | UNI_SUR_HIGH_START);
- *dest++ = (CsrUint16) ((ch & 0x03FF) | UNI_SUR_LOW_START);
+ *dest++ = (u16) ((ch >> UNI_HALF_SHIFT) | UNI_SUR_HIGH_START);
+ *dest++ = (u16) ((ch & 0x03FF) | UNI_SUR_LOW_START);
}
}
}
* Output: 0: if the strings are identical.
*
*********************************************************************************/
-CsrUint16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2)
+u16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2)
{
while (*string1 || *string2)
{
* Output: 0: if the strings are identical.
*
*********************************************************************************/
-CsrUint16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count)
+u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count)
{
while ((*string1 || *string2) && count--)
{
/*------------------------------------------------------------------*/
CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue)
{
- CsrUint16 currentIndex = 0;
+ u16 currentIndex = 0;
*returnValue = 0;
if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
{
return FALSE;
}
-CsrBool CsrHexStrToUint16(const CsrCharString *string, CsrUint16 *returnValue)
+CsrBool CsrHexStrToUint16(const CsrCharString *string, u16 *returnValue)
{
- CsrUint16 currentIndex = 0;
+ u16 currentIndex = 0;
*returnValue = 0;
if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
{
{
while (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
{
- *returnValue = (CsrUint16) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
+ *returnValue = (u16) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
currentIndex++;
if (currentIndex >= 4)
{
CsrBool CsrHexStrToUint32(const CsrCharString *string, CsrUint32 *returnValue)
{
- CsrUint16 currentIndex = 0;
+ u16 currentIndex = 0;
*returnValue = 0;
if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
{
CsrStrCpy(str, res);
}
-void CsrUInt16ToHex(CsrUint16 number, CsrCharString *str)
+void CsrUInt16ToHex(u16 number, CsrCharString *str)
{
- CsrUint16 index;
- CsrUint16 currentValue;
+ u16 index;
+ u16 currentValue;
for (index = 0; index < 4; index++)
{
- currentValue = (CsrUint16) (number & 0x000F);
+ currentValue = (u16) (number & 0x000F);
number >>= 4;
str[3 - index] = (char) (currentValue > 9 ? currentValue + 55 : currentValue + '0');
}
void CsrUInt32ToHex(CsrUint32 number, CsrCharString *str)
{
- CsrUint16 index;
+ u16 index;
CsrUint32 currentValue;
for (index = 0; index < 8; index++)
digit = 1;
/* Start from the string end */
- for (i = (CsrUint16) (CsrStrLen(str) - 1); i >= 0; i--)
+ for (i = (u16) (CsrStrLen(str) - 1); i >= 0; i--)
{
/* Only convert numbers */
if ((str[i] >= '0') && (str[i] <= '9'))
/* Base conversion */
/*------------------------------------------------------------------*/
CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue);
-CsrBool CsrHexStrToUint16(const CsrCharString *string, CsrUint16 *returnValue);
+CsrBool CsrHexStrToUint16(const CsrCharString *string, u16 *returnValue);
CsrBool CsrHexStrToUint32(const CsrCharString *string, CsrUint32 *returnValue);
CsrUint32 CsrPow(CsrUint32 base, CsrUint32 exponent);
void CsrIntToBase10(CsrInt32 number, CsrCharString *str);
-void CsrUInt16ToHex(CsrUint16 number, CsrCharString *str);
+void CsrUInt16ToHex(u16 number, CsrCharString *str);
void CsrUInt32ToHex(CsrUint32 number, CsrCharString *str);
/*------------------------------------------------------------------*/
* @return
* CsrWifiFsmContext* fsm context
*/
-extern CsrWifiFsmContext* CsrWifiFsmInit(void *applicationContext, void *externalContext, CsrUint16 maxProcesses, CsrLogTextTaskId loggingTaskId);
+extern CsrWifiFsmContext* CsrWifiFsmInit(void *applicationContext, void *externalContext, u16 maxProcesses, CsrLogTextTaskId loggingTaskId);
/**
* @brief
* @return
* void
*/
-extern void CsrWifiFsmSendEventExternal(CsrWifiFsmContext *context, CsrWifiFsmEvent *event, CsrUint16 source, CsrUint16 destination, CsrPrim primtype, CsrUint16 id);
+extern void CsrWifiFsmSendEventExternal(CsrWifiFsmContext *context, CsrWifiFsmEvent *event, u16 source, u16 destination, CsrPrim primtype, u16 id);
/**
* @brief
* @return
* void
*/
-extern void CsrWifiFsmFastForward(CsrWifiFsmContext *context, CsrUint16 ms);
+extern void CsrWifiFsmFastForward(CsrWifiFsmContext *context, u16 ms);
/**
* @brief
typedef struct CsrWifiFsmEvent
{
CsrPrim type;
- CsrUint16 primtype;
+ u16 primtype;
CsrSchedQid destination;
CsrSchedQid source;
typedef struct CsrWifiFsmTimerId
{
CsrPrim type;
- CsrUint16 primtype;
+ u16 primtype;
CsrSchedQid destination;
- CsrUint16 uniqueid;
+ u16 uniqueid;
} CsrWifiFsmTimerId;
/**
typedef struct CsrWifiFsmTimer
{
CsrPrim type;
- CsrUint16 primtype;
+ u16 primtype;
CsrSchedQid destination;
CsrSchedQid source;
{
CsrWifiFsmTimer *first;
CsrWifiFsmTimer *last;
- CsrUint16 nexttimerid;
+ u16 nexttimerid;
} CsrWifiFsmTimerList;
/**
* @param[in] context : External context
*
* @return
- * CsrUint16 a valid destination OR CSR_WIFI_FSM_ENV
+ * u16 a valid destination OR CSR_WIFI_FSM_ENV
*/
-typedef CsrUint16 (*CsrWifiFsmDestLookupCallbackPtr)(void *context, const CsrWifiFsmEvent *event);
+typedef u16 (*CsrWifiFsmDestLookupCallbackPtr)(void *context, const CsrWifiFsmEvent *event);
#ifdef CSR_WIFI_FSM_DUMP_ENABLE
const CsrBool saveAll;
const CsrWifiFsmEventEntry *eventEntryArray; /* array of transition function pointers for state */
#ifdef CSR_LOG_ENABLE
- CsrUint16 stateNumber;
+ u16 stateNumber;
const CsrCharString *stateName;
#endif
} CsrWifiFsmTableEntry;
*/
typedef struct
{
- CsrUint16 numStates; /* number of states */
+ u16 numStates; /* number of states */
const CsrWifiFsmTableEntry *aStateEventMatrix; /* state event matrix */
} CsrWifiFsmTransitionFunctionTable;
*/
typedef struct
{
- CsrUint16 transitionNumber;
+ u16 transitionNumber;
CsrWifiFsmEvent event;
- CsrUint16 fromState;
- CsrUint16 toState;
+ u16 fromState;
+ u16 toState;
CsrWifiFsmTransitionFnPtr transitionFn;
- CsrUint16 transitionCount; /* number consecutive of times this transition was seen */
+ u16 transitionCount; /* number consecutive of times this transition was seen */
#ifdef CSR_LOG_ENABLE
const CsrCharString *transitionName;
#endif
*/
typedef struct
{
- CsrUint16 numTransitions;
+ u16 numTransitions;
CsrWifiFsmTransitionRecord records[CSR_WIFI_FSM_MAX_TRANSITION_HISTORY];
} CsrWifiFsmTransitionRecords;
#endif
typedef struct
{
const CsrWifiFsmProcessStateMachine *fsmInfo; /* state machine info that is constant regardless of context */
- CsrUint16 instanceId; /* Runtime process id */
- CsrUint16 state; /* Current state */
+ u16 instanceId; /* Runtime process id */
+ u16 state; /* Current state */
void *params; /* Instance user data */
CsrWifiFsmEventList savedEventQueue; /* The saved event queue */
struct CsrWifiFsmInstanceEntry *subFsm; /* Sub Fsm instance data */
* @return
* void
*/
-typedef void (*CsrWifiFsmOnStateChangeFnPtr)(void *extContext, CsrUint16 nextstate);
+typedef void (*CsrWifiFsmOnStateChangeFnPtr)(void *extContext, u16 nextstate);
/**
* @brief
CsrBool useTempSaveList; /* Should the temp save list be used */
CsrWifiFsmEventList tempSaveList; /* The temp save event queue */
CsrWifiFsmEvent *eventForwardedOrSaved; /* The event that was forwarded or Saved */
- CsrUint16 maxProcesses; /* Size of instanceArray */
- CsrUint16 numProcesses; /* Current number allocated in instanceArray */
+ u16 maxProcesses; /* Size of instanceArray */
+ u16 numProcesses; /* Current number allocated in instanceArray */
CsrWifiFsmInstanceEntry *instanceArray; /* Array of processes for this component */
CsrWifiFsmInstanceEntry *ownerInstance; /* The Process that owns currentInstance (SubFsm support) */
CsrWifiFsmInstanceEntry *currentInstance; /* Current Process that is executing */
CsrWifiFsmOnEventFnPtr onInvalidCallback; /* Invalid event Callback */
#endif
#ifdef CSR_WIFI_FSM_DUMP_ENABLE
- CsrUint16 masterTransitionNumber; /* Increments on every transition */
+ u16 masterTransitionNumber; /* Increments on every transition */
#endif
};
/*****************************************************************************
* CardGetDataSlotSize
*/
-CsrUint16 CardGetDataSlotSize(card_t *card);
+u16 CardGetDataSlotSize(card_t *card);
/*****************************************************************************
* CardWriteBulkData -
/*****************************************************************************
* CardGetFreeFromHostDataSlots -
*/
-CsrUint16 CardGetFreeFromHostDataSlots(card_t *card);
+u16 CardGetFreeFromHostDataSlots(card_t *card);
-CsrUint16 CardAreAllFromHostDataSlotsEmpty(card_t *card);
+u16 CardAreAllFromHostDataSlotsEmpty(card_t *card);
CsrResult card_start_processor(card_t *card, enum unifi_dbg_processors_select which);
#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
void unifi_debug_log_to_buf(const CsrCharString *fmt, ...);
void unifi_debug_string_to_buf(const CsrCharString *str);
-void unifi_debug_hex_to_buf(const CsrCharString *buff, CsrUint16 length);
+void unifi_debug_hex_to_buf(const CsrCharString *buff, u16 length);
#endif
static CsrResult card_hw_init(card_t *card)
{
CsrUint32 slut_address;
- CsrUint16 initialised;
- CsrUint16 finger_print;
+ u16 initialised;
+ u16 finger_print;
symbol_t slut;
sdio_config_data_t *cfg_data;
u8 cfg_data_buf[SDIO_CONFIG_DATA_SIZE];
*/
while (!search_4slut_again)
{
- CsrUint16 s;
+ u16 s;
CsrUint32 l;
r = unifi_card_read16(card, slut_address, &s);
func_exit_r(CSR_WIFI_HIP_RESULT_INVALID_VALUE);
return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
}
- cfg_data->tohost_signal_padding = (CsrUint16) (card->sdio_io_block_size / cfg_data->sig_frag_size);
+ cfg_data->tohost_signal_padding = (u16) (card->sdio_io_block_size / cfg_data->sig_frag_size);
unifi_info(card->ospriv, "SDIO block size %d requires %d padding chunks\n",
card->sdio_io_block_size, cfg_data->tohost_signal_padding);
r = unifi_card_write16(card, slut.obj + SDIO_TO_HOST_SIG_PADDING_OFFSET, cfg_data->tohost_signal_padding);
}
if (r == CSR_RESULT_SUCCESS)
{
- CsrUint16 mbox2;
+ u16 mbox2;
CsrInt16 enabled = io_enable & (1 << card->function);
if (!enabled)
CsrResult card_wait_for_firmware_to_start(card_t *card, CsrUint32 *paddr)
{
CsrInt32 i;
- CsrUint16 mbox0, mbox1;
+ u16 mbox0, mbox1;
CsrResult r;
func_enter();
*/
static CsrResult card_access_panic(card_t *card)
{
- CsrUint16 data_u16 = 0;
+ u16 data_u16 = 0;
CsrInt32 i;
CsrResult r, sr;
void unifi_read_panic(card_t *card)
{
CsrResult r;
- CsrUint16 p_code, p_arg;
+ u16 p_code, p_arg;
func_enter();
/* Get initial signal counts from UniFi, in case it has not been reset. */
{
- CsrUint16 s;
+ u16 s;
/* Get the from-host-signals-written count */
r = unifi_card_read16(card, card->sdio_ctrl_addr + 0, &s);
*/
static void CardCheckDynamicReservation(card_t *card, unifi_TrafficQueue queue)
{
- CsrUint16 q_len, active_queues = 0, excess_queue_slots, div_extra_slots,
+ u16 q_len, active_queues = 0, excess_queue_slots, div_extra_slots,
queue_fair_share, reserved_slots = 0, q, excess_need_queues = 0, unmovable_slots = 0;
CsrInt32 i;
q_t *sigq;
- CsrUint16 num_data_slots = card->config_data.num_fromhost_data_slots - UNIFI_RESERVED_COMMAND_SLOTS;
+ u16 num_data_slots = card->config_data.num_fromhost_data_slots - UNIFI_RESERVED_COMMAND_SLOTS;
func_enter();
#endif
-CsrUint16 CardGetDataSlotSize(card_t *card)
+u16 CardGetDataSlotSize(card_t *card)
{
return card->config_data.data_slot_size;
} /* CardGetDataSlotSize() */
* Number of free from-host bulk data slots.
* ---------------------------------------------------------------------------
*/
-CsrUint16 CardGetFreeFromHostDataSlots(card_t *card)
+u16 CardGetFreeFromHostDataSlots(card_t *card)
{
- CsrUint16 i, n = 0;
+ u16 i, n = 0;
func_enter();
* 0 Some or all the from-host bulk data slots are in use.
* ---------------------------------------------------------------------------
*/
-CsrUint16 CardAreAllFromHostDataSlotsEmpty(card_t *card)
+u16 CardAreAllFromHostDataSlotsEmpty(card_t *card)
{
- CsrUint16 i;
+ u16 i;
for (i = 0; i < card->config_data.num_fromhost_data_slots; i++)
{
{
CsrUint32 gbl_chip_version;
CsrResult r;
- CsrUint16 ver;
+ u16 ver;
func_enter();
static CsrResult unifi_reset_hardware(card_t *card)
{
CsrResult r;
- CsrUint16 new_block_size = UNIFI_IO_BLOCK_SIZE;
+ u16 new_block_size = UNIFI_IO_BLOCK_SIZE;
CsrResult csrResult;
func_enter();
*/
CsrResult CardWriteBulkData(card_t *card, card_signal_t *csptr, unifi_TrafficQueue queue)
{
- CsrUint16 i, slots[UNIFI_MAX_DATA_REFERENCES], j = 0;
+ u16 i, slots[UNIFI_MAX_DATA_REFERENCES], j = 0;
u8 *packed_sigptr, num_slots_required = 0;
bulk_data_desc_t *bulkdata = csptr->bulkdata;
CsrInt16 h, nslots;
* Fill in the slot number in the SIGNAL structure but
* preserve the offset already in there
*/
- SET_PACKED_DATAREF_SLOT(packed_sigptr, i, slots[j] | (((CsrUint16)packed_sigptr[SIZEOF_SIGNAL_HEADER + (i * SIZEOF_DATAREF) + 1]) << 8));
+ SET_PACKED_DATAREF_SLOT(packed_sigptr, i, slots[j] | (((u16)packed_sigptr[SIZEOF_SIGNAL_HEADER + (i * SIZEOF_DATAREF) + 1]) << 8));
SET_PACKED_DATAREF_LEN(packed_sigptr, i, bulkdata[i].data_length);
/* Do not copy the data, just store the information to them */
static CsrResult firmware_present_in_flash(card_t *card)
{
CsrResult r;
- CsrUint16 m1, m5;
+ u16 m1, m5;
if (ChipHelper_HasRom(card->helper))
{
CsrUint32 occupied_fh;
q_t *sigq;
- CsrUint16 nslots, i;
+ u16 nslots, i;
CsrMemSet(hipqosinfo, 0, sizeof(unifi_HipQosInfo));
occupied_fh = (card->from_host_signals_w - count_fhr) % 128;
- hipqosinfo->free_fh_fw_slots = (CsrUint16)(card->config_data.num_fromhost_sig_frags - occupied_fh);
+ hipqosinfo->free_fh_fw_slots = (u16)(card->config_data.num_fromhost_sig_frags - occupied_fh);
}
* indicate incompatible changes. The LSB gives the minor revision number,
* used to indicate changes that maintain backwards compatibility.
*/
- CsrUint16 version;
+ u16 version;
/*
* offset from the start of the shared data memory to the SD IO
* control structure.
*/
- CsrUint16 sdio_ctrl_offset;
+ u16 sdio_ctrl_offset;
/* Buffer handle of the from-host signal queue */
- CsrUint16 fromhost_sigbuf_handle;
+ u16 fromhost_sigbuf_handle;
/* Buffer handle of the to-host signal queue */
- CsrUint16 tohost_sigbuf_handle;
+ u16 tohost_sigbuf_handle;
/*
* Maximum number of signal primitive or bulk data command fragments that may be
* pending in the to-hw signal queue.
*/
- CsrUint16 num_fromhost_sig_frags;
+ u16 num_fromhost_sig_frags;
/*
* Number of signal primitive or bulk data command fragments that must be pending
* Note that the hw may place more signals in the to-host signal queue
* than indicated by this field.
*/
- CsrUint16 num_tohost_sig_frags;
+ u16 num_tohost_sig_frags;
/*
* Number of to-hw bulk data slots. Slots are numbered from 0 (zero) to
* one less than the value in this field
*/
- CsrUint16 num_fromhost_data_slots;
+ u16 num_fromhost_data_slots;
/*
* Number of frm-hw bulk data slots. Slots are numbered from 0 (zero) to
* one less than the value in this field
*/
- CsrUint16 num_tohost_data_slots;
+ u16 num_tohost_data_slots;
/*
* Size of the bulk data slots (2 octets)
* The size of the bulk data slots in octets. This will usually be
* the size of the largest MSDU. The value should always be even.
*/
- CsrUint16 data_slot_size;
+ u16 data_slot_size;
/*
* Indicates that the host has finished the initialisation sequence.
* Initialised to 0x0000 by the firmware, and set to 0x0001 by us.
*/
- CsrUint16 initialised;
+ u16 initialised;
/* Added by protocol version 0x0001 */
CsrUint32 overlay_size;
/* Added by protocol version 0x0300 */
- CsrUint16 data_slot_round;
- CsrUint16 sig_frag_size;
+ u16 data_slot_round;
+ u16 sig_frag_size;
/* Added by protocol version 0x0500 */
- CsrUint16 tohost_signal_padding;
+ u16 tohost_signal_padding;
} sdio_config_data_t;
/*
/* Structure for a bulk data transfer command */
typedef struct
{
- CsrUint16 cmd_and_len; /* bits 12-15 cmd, bits 0-11 len */
- CsrUint16 data_slot; /* slot number, perhaps OR'd with SLOT_DIR_TO_HOST */
- CsrUint16 offset;
- CsrUint16 buffer_handle;
+ u16 cmd_and_len; /* bits 12-15 cmd, bits 0-11 len */
+ u16 data_slot; /* slot number, perhaps OR'd with SLOT_DIR_TO_HOST */
+ u16 offset;
+ u16 buffer_handle;
} bulk_data_cmd_t;
u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
/* Length of the SIGNAL inside sigbuf */
- CsrUint16 signal_length;
+ u16 signal_length;
bulk_data_desc_t bulkdata[UNIFI_MAX_DATA_REFERENCES];
} card_signal_t;
card_signal_t *q_body;
/* Num elements in queue (capacity is one less than this!) */
- CsrUint16 q_length;
+ u16 q_length;
- CsrUint16 q_wr_ptr;
- CsrUint16 q_rd_ptr;
+ u16 q_wr_ptr;
+ u16 q_rd_ptr;
CsrCharString name[UNIFI_QUEUE_NAME_MAX_LENGTH];
} q_t;
*/
typedef struct
{
- CsrUint16 from_host_used_slots[UNIFI_NO_OF_TX_QS];
- CsrUint16 from_host_max_slots[UNIFI_NO_OF_TX_QS];
- CsrUint16 from_host_reserved_slots[UNIFI_NO_OF_TX_QS];
+ u16 from_host_used_slots[UNIFI_NO_OF_TX_QS];
+ u16 from_host_max_slots[UNIFI_NO_OF_TX_QS];
+ u16 from_host_reserved_slots[UNIFI_NO_OF_TX_QS];
/* Parameters to determine if a queue was active.
If number of packets sent is greater than the threshold
re reservation is done, it is important not to keep this
value too low */
/* Packets sent during this interval */
- CsrUint16 packets_txed[UNIFI_NO_OF_TX_QS];
- CsrUint16 total_packets_txed;
+ u16 packets_txed[UNIFI_NO_OF_TX_QS];
+ u16 total_packets_txed;
/* Number of packets to see if slots need to be reassigned */
- CsrUint16 packets_interval;
+ u16 packets_interval;
/* Once a queue reaches a stable state, avoid processing */
CsrBool queue_stable[UNIFI_NO_OF_TX_QS];
* params:
* const q_t *q
* returns:
- * CsrUint16
+ * u16
*/
#define CSR_WIFI_HIP_Q_SLOTS_USED(q) \
(((q)->q_wr_ptr - (q)->q_rd_ptr < 0)? \
* params:
* const q_t *q
* returns:
- * CsrUint16
+ * u16
*/
#define CSR_WIFI_HIP_Q_SLOTS_FREE(q) \
((q)->q_length - CSR_WIFI_HIP_Q_SLOTS_USED((q)) - 1)
/* Return slot signal data pointer
* params:
* const q_t *q
- * CsrUint16 slot
+ * u16 slot
* returns:
* card_signal_t *
*/
* params:
* const q_t *q
* returns:
- * CsrUint16 slot offset
+ * u16 slot offset
*/
#define CSR_WIFI_HIP_Q_NEXT_R_SLOT(q) \
((q)->q_rd_ptr)
* params:
* const q_t *q
* returns:
- * CsrUint16 slot offset
+ * u16 slot offset
*/
#define CSR_WIFI_HIP_Q_NEXT_W_SLOT(q) \
((q)->q_wr_ptr)
/* Return updated queue pointer wrapped around its length
* params:
* const q_t *q
- * CsrUint16 x amount to add to queue pointer
+ * u16 x amount to add to queue pointer
* returns:
- * CsrUint16 wrapped queue pointer
+ * u16 wrapped queue pointer
*/
#define CSR_WIFI_HIP_Q_WRAP(q, x) \
((((x) >= (q)->q_length)?((x) % (q)->q_length) : (x)))
CsrCharString build_id_string[128];
/* Retrieve from SDIO driver. */
- CsrUint16 chip_id;
+ u16 chip_id;
/* Read from GBL_CHIP_VERSION. */
- CsrUint16 chip_version;
+ u16 chip_version;
/* From the SDIO driver (probably 1) */
u8 function;
#define card_tx_q_unpause(card, q) (card->tx_q_paused_flag[q] = 0)
#define card_tx_q_pause(card, q) (card->tx_q_paused_flag[q] = 1)
- CsrUint16 tx_q_paused_flag[UNIFI_TRAFFIC_Q_MAX + 1 + UNIFI_NO_OF_TX_QS]; /* defensive more than big enough */
+ u16 tx_q_paused_flag[UNIFI_TRAFFIC_Q_MAX + 1 + UNIFI_NO_OF_TX_QS]; /* defensive more than big enough */
/* UDI callback for logging UniFi interactions */
udi_func_t udi_hook;
{
u8 *buf; /* buffer area */
u8 *ptr; /* current pos */
- CsrUint16 count; /* signal count */
- CsrUint16 bufsize;
+ u16 count; /* signal count */
+ u16 bufsize;
} fh_buffer;
struct sigbuf th_buffer;
u8 memory_resources_allocated;
/* UniFi SDIO I/O Block size. */
- CsrUint16 sdio_io_block_size;
+ u16 sdio_io_block_size;
/* Pad transfer sizes to SDIO block boundaries */
CsrBool sdio_io_block_pad;
/* Historic firmware panic codes */
CsrUint32 panic_data_phy_addr;
CsrUint32 panic_data_mac_addr;
- CsrUint16 last_phy_panic_code;
- CsrUint16 last_phy_panic_arg;
- CsrUint16 last_mac_panic_code;
- CsrUint16 last_mac_panic_arg;
+ u16 last_phy_panic_code;
+ u16 last_phy_panic_arg;
+ u16 last_mac_panic_code;
+ u16 last_mac_panic_arg;
#ifdef CSR_PRE_ALLOC_NET_DATA
bulk_data_desc_t bulk_data_desc_list[BULK_DATA_PRE_ALLOC_NUM];
- CsrUint16 prealloc_netdata_r;
- CsrUint16 prealloc_netdata_w;
+ u16 prealloc_netdata_r;
+ u16 prealloc_netdata_w;
#endif
}; /* struct card */
CsrResult unifi_read32(card_t *card, CsrUint32 unifi_addr, CsrUint32 *pdata);
CsrResult unifi_readnz(card_t *card, CsrUint32 unifi_addr,
- void *pdata, CsrUint16 len);
+ void *pdata, u16 len);
CsrInt32 unifi_read_shared_count(card_t *card, CsrUint32 addr);
-CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len);
+CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len);
CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle,
void *pdata, CsrUint32 len, CsrInt16 direction);
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_direct16(card_t *card, CsrUint32 addr, CsrUint16 *pdata);
+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, CsrUint16 len);
+CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len);
-CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, CsrUint16 data);
-CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 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 sdio_read_f0(card_t *card, CsrUint32 addr, u8 *pdata);
CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, u8 data);
CsrResult prealloc_netdata_alloc(card_t *card);
#endif
/* For diagnostic use */
-void dump(void *mem, CsrUint16 len);
-void dump16(void *mem, CsrUint16 len);
+void dump(void *mem, u16 len);
+void dump16(void *mem, u16 len);
#ifdef __cplusplus
}
static CsrResult flush_fh_buffer(card_t *card);
-static CsrResult check_fh_sig_slots(card_t *card, CsrUint16 needed, CsrInt32 *space);
+static CsrResult check_fh_sig_slots(card_t *card, u16 needed, CsrInt32 *space);
static CsrResult read_to_host_signals(card_t *card, CsrInt32 *processed);
static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed);
static CsrResult process_bulk_data_command(card_t *card,
const u8 *cmdptr,
- CsrInt16 cmd, CsrUint16 len);
+ CsrInt16 cmd, u16 len);
static CsrResult process_clear_slot_command(card_t *card,
const u8 *cmdptr);
static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed);
*
* ---------------------------------------------------------------------------
*/
-void unifi_debug_hex_to_buf(const CsrCharString *buff, CsrUint16 length)
+void unifi_debug_hex_to_buf(const CsrCharString *buff, u16 length)
{
CsrCharString s[5];
- CsrUint16 i;
+ u16 i;
for (i = 0; i < length; i = i + 2)
{
- CsrUInt16ToHex(*((CsrUint16 *)(buff + i)), s);
+ CsrUInt16ToHex(*((u16 *)(buff + i)), s);
unifi_debug_string_to_buf(s);
}
}
CsrBool pending;
CsrInt32 iostate, j;
const enum unifi_low_power_mode low_power_mode = card->low_power_mode;
- CsrUint16 data_slots_used = 0;
+ u16 data_slots_used = 0;
/* Process request to raise the maximum SDIO clock */
}
card->th_buffer.ptr += unread_bytes;
- card->th_buffer.count += (CsrUint16)unread_chunks;
+ card->th_buffer.count += (u16)unread_chunks;
*processed = 1;
u8 *bufptr;
bulk_data_param_t data_ptrs;
CsrInt16 cmd;
- CsrUint16 sig_len;
+ u16 sig_len;
CsrInt16 i;
- CsrUint16 chunks_in_buf;
- CsrUint16 bytes_transferred = 0;
+ u16 chunks_in_buf;
+ u16 bytes_transferred = 0;
CsrResult r = CSR_RESULT_SUCCESS;
*processed = 0;
*/
if (cmd == SDIO_CMD_SIGNAL)
{
- chunks_in_buf = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(sig_len + 2));
+ chunks_in_buf = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(sig_len + 2));
}
else
{
chunks_in_buf = 1;
}
- if (chunks_in_buf > (CsrUint16)pending)
+ if (chunks_in_buf > (u16)pending)
{
unifi_error(card->ospriv, "incomplete signal (0x%x?): need %d chunks, got %d\n",
GET_SIGNAL_ID(bufptr + 2),
for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
{
/* Retrieve dataRefs[i].DataLength */
- CsrUint16 data_len = GET_PACKED_DATAREF_LEN(bufptr + 2, i);
+ u16 data_len = GET_PACKED_DATAREF_LEN(bufptr + 2, i);
/*
* The bulk data length in the signal can not be greater than
{
/* Get host tag and transmission status */
CsrUint32 host_tag = GET_PACKED_MA_PACKET_CONFIRM_HOST_TAG(bufptr + 2);
- CsrUint16 status = GET_PACKED_MA_PACKET_CONFIRM_TRANSMISSION_STATUS(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",
GET_SIGNAL_ID(bufptr + 2), host_tag, status);
if (status && (card->fh_slot_host_tag_record))
{
- CsrUint16 num_fh_slots = card->config_data.num_fromhost_data_slots;
+ u16 num_fh_slots = card->config_data.num_fromhost_data_slots;
/* search through the list of slot records and match with host tag
* If a slot is not yet cleared then clear the slot from here
*/
static CsrResult process_clear_slot_command(card_t *card, const u8 *cmdptr)
{
- CsrUint16 data_slot;
+ u16 data_slot;
CsrInt16 slot;
data_slot = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cmdptr + SIZEOF_UINT16);
* ---------------------------------------------------------------------------
*/
static CsrResult process_bulk_data_command(card_t *card, const u8 *cmdptr,
- CsrInt16 cmd, CsrUint16 len)
+ CsrInt16 cmd, u16 len)
{
bulk_data_desc_t *bdslot;
#ifdef CSR_WIFI_ALIGNMENT_WORKAROUND
* CSR_RESULT_SUCCESS, otherwise CSR error code on error.
* ---------------------------------------------------------------------------
*/
-static CsrResult check_fh_sig_slots(card_t *card, CsrUint16 needed, CsrInt32 *space_fh)
+static CsrResult check_fh_sig_slots(card_t *card, u16 needed, CsrInt32 *space_fh)
{
CsrUint32 count_fhw;
CsrUint32 occupied_fh, slots_fh;
*/
#define ROUND_UP_NEEDED_CHUNKS(_card, _needed_chunks) \
{ \
- CsrUint16 _chunks_per_block; \
- CsrUint16 _chunks_in_last_block; \
+ u16 _chunks_per_block; \
+ u16 _chunks_in_last_block; \
\
if (_card->sdio_io_block_pad) \
{ \
#define ROUND_UP_SPACE_CHUNKS(_card, _space_chunks) \
{ \
- CsrUint16 _chunks_per_block; \
+ u16 _chunks_per_block; \
\
if (_card->sdio_io_block_pad) \
{ \
q_t *sigq = &card->fh_command_queue;
CsrResult r;
- CsrUint16 pending_sigs;
- CsrUint16 pending_chunks;
- CsrUint16 needed_chunks;
+ u16 pending_sigs;
+ u16 pending_chunks;
+ u16 needed_chunks;
CsrInt32 space_chunks;
- CsrUint16 q_index;
+ u16 q_index;
*processed = 0;
* Note that GET_CHUNKS_FOR() needs the size of the packed
* (wire-formatted) structure
*/
- pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(csptr->signal_length + 2));
+ pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(csptr->signal_length + 2));
}
/*
* Coalesce as many from-host signals as possible
* into a single block and write using a single CMD53
*/
- if (needed_chunks > (CsrUint16)space_chunks)
+ if (needed_chunks > (u16)space_chunks)
{
/* Round up to the block size if necessary */
ROUND_UP_SPACE_CHUNKS(card, space_chunks);
* If the f/w has less free chunks than those already pending
* return immediately.
*/
- if ((CsrUint16)space_chunks <= card->fh_buffer.count)
+ if ((u16)space_chunks <= card->fh_buffer.count)
{
/*
* No room in UniFi for any signals after the buffered bulk
card->generate_interrupt = 1;
return CSR_RESULT_SUCCESS;
}
- pending_chunks = (CsrUint16)(space_chunks - card->fh_buffer.count);
+ pending_chunks = (u16)(space_chunks - card->fh_buffer.count);
}
while (pending_sigs-- && pending_chunks > 0)
{
card_signal_t *csptr;
CsrInt16 i;
- CsrUint16 sig_chunks, total_length, free_chunks_in_fh_buffer;
+ u16 sig_chunks, total_length, free_chunks_in_fh_buffer;
bulk_data_param_t bulkdata;
u8 *packed_sigptr;
- CsrUint16 signal_length = 0;
+ u16 signal_length = 0;
/* Retrieve the entry at the head of the queue */
q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(sigq);
}
/* Need space for 2-byte SDIO protocol header + signal */
- sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(signal_length + 2));
+ sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(signal_length + 2));
free_chunks_in_fh_buffer = GET_CHUNKS_FOR(card->config_data.sig_frag_size,
- (CsrUint16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
+ (u16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
if (free_chunks_in_fh_buffer < sig_chunks)
{
/* No more room */
unifi_notice(card->ospriv, "proc_fh_cmd_q: no room in fh buffer for 0x%.4X, deferring\n",
- (CsrUint16)(GET_SIGNAL_ID(csptr->sigbuf)));
+ (u16)(GET_SIGNAL_ID(csptr->sigbuf)));
break;
}
if (CSR_RESULT_FAILURE == CardWriteBulkData(card, csptr, UNIFI_TRAFFIC_Q_MLME))
{
unifi_notice(card->ospriv, "proc_fh_cmd_q: no fh data slots for 0x%.4X, deferring\n",
- (CsrUint16)(GET_SIGNAL_ID(csptr->sigbuf)));
+ (u16)(GET_SIGNAL_ID(csptr->sigbuf)));
break;
}
CsrResult r;
CsrInt16 n = 0;
CsrInt32 q_no;
- CsrUint16 pending_sigs = 0;
- CsrUint16 pending_chunks = 0;
- CsrUint16 needed_chunks;
+ u16 pending_sigs = 0;
+ u16 pending_chunks = 0;
+ u16 needed_chunks;
CsrInt32 space_chunks;
- CsrUint16 q_index;
+ u16 q_index;
CsrUint32 host_tag = 0;
- CsrUint16 slot_num = 0;
+ u16 slot_num = 0;
*processed = 0;
* Note that GET_CHUNKS_FOR() needs the size of the packed
* (wire-formatted) structure
*/
- pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(csptr->signal_length + 2));
+ pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(csptr->signal_length + 2));
}
}
/* Coalesce as many from-host signals as possible
into a single block and write using a single CMD53 */
- if (needed_chunks > (CsrUint16)space_chunks)
+ if (needed_chunks > (u16)space_chunks)
{
/* Round up to the block size if necessary */
ROUND_UP_SPACE_CHUNKS(card, space_chunks);
- if ((CsrUint16)space_chunks <= card->fh_buffer.count)
+ if ((u16)space_chunks <= card->fh_buffer.count)
{
/*
* No room in UniFi for any signals after the buffered bulk
return 0;
}
- pending_chunks = (CsrUint16)space_chunks - card->fh_buffer.count;
+ pending_chunks = (u16)space_chunks - card->fh_buffer.count;
}
q_no = UNIFI_NO_OF_TX_QS - 1;
do
{
card_signal_t *csptr;
- CsrUint16 sig_chunks, total_length, free_chunks_in_fh_buffer;
+ u16 sig_chunks, total_length, free_chunks_in_fh_buffer;
bulk_data_param_t bulkdata;
u8 *packed_sigptr;
- CsrUint16 signal_length = 0;
+ u16 signal_length = 0;
/* if this queue is empty go to next one. */
if (CSR_WIFI_HIP_Q_SLOTS_USED(&sigq[q_no]) == 0)
}
/* Need space for 2-byte SDIO protocol header + signal */
- sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(signal_length + 2));
+ sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(signal_length + 2));
free_chunks_in_fh_buffer = GET_CHUNKS_FOR(card->config_data.sig_frag_size,
- (CsrUint16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
+ (u16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
if (free_chunks_in_fh_buffer < sig_chunks)
{
/* No more room */
static CsrResult flush_fh_buffer(card_t *card)
{
CsrResult r;
- CsrUint16 len;
- CsrUint16 sig_units;
- CsrUint16 data_round;
- CsrUint16 chunks_in_last_block;
- CsrUint16 padding_chunks;
- CsrUint16 i;
+ u16 len;
+ u16 sig_units;
+ u16 data_round;
+ u16 chunks_in_last_block;
+ u16 padding_chunks;
+ u16 i;
len = card->fh_buffer.ptr - card->fh_buffer.buf;
static CsrResult retrying_read16(card_t *card, CsrInt16 funcnum,
- CsrUint32 addr, CsrUint16 *pdata)
+ CsrUint32 addr, u16 *pdata)
{
CsrSdioFunction *sdio = card->sdio_if;
CsrResult r = CSR_RESULT_SUCCESS;
static CsrResult retrying_write16(card_t *card, CsrInt16 funcnum,
- CsrUint32 addr, CsrUint16 data)
+ CsrUint32 addr, u16 data)
{
CsrSdioFunction *sdio = card->sdio_if;
CsrResult r = CSR_RESULT_SUCCESS;
CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, u8 *pdata)
{
#ifdef CSR_WIFI_TRANSPORT_CSPI
- CsrUint16 w;
+ u16 w;
CsrResult r;
r = retrying_read16(card, card->function, addr, &w);
}
#ifdef CSR_WIFI_TRANSPORT_CSPI
- return retrying_write16(card, card->function, addr, (CsrUint16)data);
+ return retrying_write16(card, card->function, addr, (u16)data);
#else
return retrying_write8(card, card->function, addr, data);
#endif
* even address is read.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, CsrUint16 *pdata)
+CsrResult unifi_read_direct16(card_t *card, CsrUint32 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, CsrUint16 data)
+CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, u16 data)
{
return retrying_write16(card, card->function, addr, data);
} /* unifi_write_direct16() */
CsrResult unifi_read_direct32(card_t *card, CsrUint32 addr, CsrUint32 *pdata)
{
CsrResult r;
- CsrUint16 w0, w1;
+ u16 w0, w1;
r = retrying_read16(card, card->function, addr, &w0);
if (r != CSR_RESULT_SUCCESS)
* even address is read.
* ---------------------------------------------------------------------------
*/
-static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len, s8 m, CsrUint32 *num)
+static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pdata, u16 len, s8 m, CsrUint32 *num)
{
CsrResult r;
CsrUint32 i;
u8 *cptr;
- CsrUint16 w;
+ u16 w;
*num = 0;
* even address is read.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len)
+CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len)
{
CsrUint32 num;
* This means we must write data as pairs of bytes in reverse order.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len)
+CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len)
{
CsrResult r;
u8 *cptr;
*/
static CsrResult set_dmem_page(card_t *card, CsrUint32 dmem_addr, CsrUint32 *paddr)
{
- CsrUint16 page, addr;
+ u16 page, addr;
CsrUint32 len;
CsrResult r;
static CsrResult set_pmem_page(card_t *card, CsrUint32 pmem_addr,
enum chip_helper_window_type mem_type, CsrUint32 *paddr)
{
- CsrUint16 page, addr;
+ u16 page, addr;
CsrUint32 len;
CsrResult r;
CsrUint32 sdio_addr;
CsrResult r;
#ifdef CSR_WIFI_TRANSPORT_CSPI
- CsrUint16 w;
+ u16 w;
#endif
r = set_page(card, unifi_addr, &sdio_addr);
CsrUint32 sdio_addr;
CsrResult r;
#ifdef CSR_WIFI_TRANSPORT_CSPI
- CsrUint16 w;
+ u16 w;
#endif
r = set_page(card, unifi_addr, &sdio_addr);
* CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, CsrUint16 *pdata)
+CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, u16 *pdata)
{
CsrUint32 sdio_addr;
CsrResult r;
* CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, CsrUint16 data)
+CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, u16 data)
{
CsrUint32 sdio_addr;
CsrResult r;
* CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_readn_match(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len, s8 match)
+CsrResult unifi_readn_match(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len, s8 match)
{
CsrUint32 sdio_addr;
CsrResult r;
} /* unifi_readn_match() */
-CsrResult unifi_card_readn(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len)
+CsrResult unifi_card_readn(card_t *card, CsrUint32 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, CsrUint16 len)
+CsrResult unifi_readnz(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len)
{
return unifi_readn_match(card, unifi_addr, pdata, len, 0);
} /* unifi_readnz() */
* CSR_WIFI_HIP_RESULT_INVALID_VALUE an odd length or length too big.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len)
+CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len)
{
CsrUint32 sdio_addr;
CsrResult r;
static CsrResult csr_sdio_block_rw(card_t *card, CsrInt16 funcnum,
CsrUint32 addr, u8 *pdata,
- CsrUint16 count, CsrInt16 dir_is_write)
+ u16 count, CsrInt16 dir_is_write)
{
CsrResult csrResult;
pdata, (direction == UNIFI_SDIO_READ)?"To" : "From");
if (direction == UNIFI_SDIO_WRITE)
{
- dump(pdata, (CsrUint16)len);
+ dump(pdata, (u16)len);
}
else
{
while (1)
{
csrResult = csr_sdio_block_rw(card, card->function, handle,
- (u8 *)pdata, (CsrUint16)len,
+ (u8 *)pdata, (u16)len,
direction);
if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
{
{
if (dump_read)
{
- dump(pdata, (CsrUint16)len);
+ dump(pdata, (u16)len);
}
break;
}
CsrResult csrResult;
csrResult = csr_sdio_block_rw(card, card->function, handle,
- (u8 *)pdata, (CsrUint16)len, direction);
+ (u8 *)pdata, (u16)len, direction);
if (csrResult != CSR_RESULT_SUCCESS)
{
unifi_error(card->ospriv, "Block %s failed\n",
{ 0x????, 0x???? }*/
};
-static const CsrUint16 reset_program_a_v1_or_v2[] = {
+static const u16 reset_program_a_v1_or_v2[] = {
0x0000
};
-static const CsrUint16 reset_program_b_v1_or_v2[] = {
+static const u16 reset_program_b_v1_or_v2[] = {
0x0010, 0xFE00, 0xA021, 0xFF00, 0x8111, 0x0009, 0x0CA4, 0x0114,
0x0280, 0x04F8, 0xFE00, 0x6F25, 0x06E0, 0x0010, 0xFC00, 0x0121,
0xFC00, 0x0225, 0xFE00, 0x7125, 0xFE00, 0x6D11, 0x03F0, 0xFE00,
}
-ChipDescript* ChipHelper_GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81)
+ChipDescript* ChipHelper_GetVersionAny(u16 from_FF9A, u16 from_FE81)
{
CsrUint32 i;
}
-ChipDescript* ChipHelper_GetVersionUniFi(CsrUint16 ver)
+ChipDescript* ChipHelper_GetVersionUniFi(u16 ver)
{
return ChipHelper_GetVersionAny(0x0000, ver);
}
}
-ChipDescript* ChipHelper_GetVersionBlueCore(enum chip_helper_bluecore_age bc_age, CsrUint16 version)
+ChipDescript* ChipHelper_GetVersionBlueCore(enum chip_helper_bluecore_age bc_age, u16 version)
{
if (bc_age == chip_helper_bluecore_pre_bc7)
{
/*
* Map register addresses between HOST and SPI access.
*/
-CsrUint16 ChipHelper_MapAddress_SPI2HOST(ChipDescript *chip_help, CsrUint16 addr)
+u16 ChipHelper_MapAddress_SPI2HOST(ChipDescript *chip_help, u16 addr)
{
CsrUint32 i;
for (i = 0; i < chip_help->map.len; i++)
}
-CsrUint16 ChipHelper_MapAddress_HOST2SPI(ChipDescript *chip_help, CsrUint16 addr)
+u16 ChipHelper_MapAddress_HOST2SPI(ChipDescript *chip_help, u16 addr)
{
CsrUint32 i;
for (i = 0; i < chip_help->map.len; i++)
start is unusable because something else is cluttering up
the address map then that is taken into account and this
function returns that address justt past that. */
-CsrUint16 ChipHelper_WINDOW_ADDRESS(ChipDescript *chip_help,
+u16 ChipHelper_WINDOW_ADDRESS(ChipDescript *chip_help,
enum chip_helper_window_index window)
{
if (window < CHIP_HELPER_WINDOW_COUNT &&
/* This returns the size of the window minus any blocked section */
-CsrUint16 ChipHelper_WINDOW_SIZE(ChipDescript *chip_help,
+u16 ChipHelper_WINDOW_SIZE(ChipDescript *chip_help,
enum chip_helper_window_index window)
{
if (window < CHIP_HELPER_WINDOW_COUNT &&
enum chip_helper_window_index window,
enum chip_helper_window_type type,
CsrUint32 offset,
- CsrUint16 *page, CsrUint16 *addr, CsrUint32 *len)
+ u16 *page, u16 *addr, CsrUint32 *len)
{
const struct window_info_t *win;
const struct window_shift_info_t *mode;
- CsrUint16 of, pg;
+ u16 of, pg;
if (window >= CHIP_HELPER_WINDOW_COUNT)
{
return FALSE;
}
- pg = (CsrUint16)(offset >> mode->page_shift) + mode->page_offset;
- of = (CsrUint16)(offset & ((1 << mode->page_shift) - 1));
+ pg = (u16)(offset >> mode->page_shift) + mode->page_offset;
+ of = (u16)(offset & ((1 << mode->page_shift) - 1));
/* If 'blocked' is zero this does nothing, else decrease
the page register and increase the offset until we aren't
in the blocked region of the window. */
/* Address-value pairs for defining initialisation values */
struct chip_helper_init_values
{
- CsrUint16 addr;
- CsrUint16 value;
+ u16 addr;
+ u16 value;
};
/* A block of data that should be written to the device */
{
CsrUint32 gp_address;
CsrUint32 len;
- const CsrUint16 *data;
+ const u16 *data;
};
/*
FF9A is the old GBL_CHIP_VERSION register. If the high
eight bits are zero then the chip is a new (BC7 +) one
and FE81 is the _new_ GBL_CHIP_VERSION register. */
-ChipDescript* ChipHelper_GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81);
+ChipDescript* ChipHelper_GetVersionAny(u16 from_FF9A, u16 from_FE81);
/* The chip is a UniFi, but we don't know which type
The parameter is the value of UNIFI_GBL_CHIP_VERSION (0xFE81) */
-ChipDescript* ChipHelper_GetVersionUniFi(CsrUint16 version);
+ChipDescript* ChipHelper_GetVersionUniFi(u16 version);
/* This gets the version from the SDIO device id. This only
gives quite a coarse grained version, so we should update once
then "version" is read from FE81. If we don't know if we're pre
or post BC7 then we should use "GetVersionAny". */
ChipDescript* ChipHelper_GetVersionBlueCore(enum chip_helper_bluecore_age age,
- CsrUint16 version);
+ u16 version);
/* The main functions of this class are built with an X macro. This
means we can generate the C and C++ versions from the same source
#define CHIP_HELPER_LIST(m) \
CHIP_HELPER_DEF0(m, (const CsrCharString *, FriendlyName, friendly_name)) \
CHIP_HELPER_DEF0(m, (const CsrCharString *, MarketingName, marketing_name)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, DBG_EMU_CMD, regs->dbg_emu_cmd)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, DBG_HOST_PROC_SELECT, regs->host.dbg_proc_select)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, DBG_HOST_STOP_STATUS, regs->host.dbg_stop_status)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, HOST_WINDOW1_PAGE, regs->host.window1_page)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, HOST_WINDOW2_PAGE, regs->host.window2_page)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, HOST_WINDOW3_PAGE, regs->host.window3_page)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, HOST_IO_LOG_ADDR, regs->host.io_log_addr)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, DBG_SPI_PROC_SELECT, regs->spi.dbg_proc_select)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, DBG_SPI_STOP_STATUS, regs->spi.dbg_stop_status)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, SPI_WINDOW1_PAGE, regs->spi.window1_page)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, SPI_WINDOW2_PAGE, regs->spi.window2_page)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, SPI_WINDOW3_PAGE, regs->spi.window3_page)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, SPI_IO_LOG_ADDR, regs->spi.io_log_addr)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET, regs->dbg_reset)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_VALUE, regs->dbg_reset_value)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_WARN, regs->dbg_reset_warn)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_WARN_VALUE, regs->dbg_reset_warn_value)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_RESULT, regs->dbg_reset_result)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, WATCHDOG_DISABLE, regs->watchdog_disable)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, PROC_PC_SNOOP, regs->proc_pc_snoop)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, GBL_CHIP_VERSION, regs->gbl_chip_version)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, GBL_MISC_ENABLES, regs->gbl_misc_enables)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, XAP_PCH, regs->xap_pch)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, XAP_PCL, regs->xap_pcl)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX0, regs->mailbox0)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX1, regs->mailbox1)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX2, regs->mailbox2)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX3, regs->mailbox3)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, SDIO_HIP_HANDSHAKE, regs->sdio_hip_handshake)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, SDIO_HOST_INT, regs->sdio_host_int)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, COEX_STATUS, regs->coex_status)) \
- CHIP_HELPER_DEF0(m, (CsrUint16, SHARED_IO_INTERRUPT, regs->shared_io_interrupt)) \
+ CHIP_HELPER_DEF0(m, (u16, DBG_EMU_CMD, regs->dbg_emu_cmd)) \
+ CHIP_HELPER_DEF0(m, (u16, DBG_HOST_PROC_SELECT, regs->host.dbg_proc_select)) \
+ CHIP_HELPER_DEF0(m, (u16, DBG_HOST_STOP_STATUS, regs->host.dbg_stop_status)) \
+ CHIP_HELPER_DEF0(m, (u16, HOST_WINDOW1_PAGE, regs->host.window1_page)) \
+ CHIP_HELPER_DEF0(m, (u16, HOST_WINDOW2_PAGE, regs->host.window2_page)) \
+ CHIP_HELPER_DEF0(m, (u16, HOST_WINDOW3_PAGE, regs->host.window3_page)) \
+ CHIP_HELPER_DEF0(m, (u16, HOST_IO_LOG_ADDR, regs->host.io_log_addr)) \
+ CHIP_HELPER_DEF0(m, (u16, DBG_SPI_PROC_SELECT, regs->spi.dbg_proc_select)) \
+ CHIP_HELPER_DEF0(m, (u16, DBG_SPI_STOP_STATUS, regs->spi.dbg_stop_status)) \
+ CHIP_HELPER_DEF0(m, (u16, SPI_WINDOW1_PAGE, regs->spi.window1_page)) \
+ CHIP_HELPER_DEF0(m, (u16, SPI_WINDOW2_PAGE, regs->spi.window2_page)) \
+ CHIP_HELPER_DEF0(m, (u16, SPI_WINDOW3_PAGE, regs->spi.window3_page)) \
+ CHIP_HELPER_DEF0(m, (u16, SPI_IO_LOG_ADDR, regs->spi.io_log_addr)) \
+ CHIP_HELPER_DEF0(m, (u16, DBG_RESET, regs->dbg_reset)) \
+ CHIP_HELPER_DEF0(m, (u16, DBG_RESET_VALUE, regs->dbg_reset_value)) \
+ CHIP_HELPER_DEF0(m, (u16, DBG_RESET_WARN, regs->dbg_reset_warn)) \
+ CHIP_HELPER_DEF0(m, (u16, DBG_RESET_WARN_VALUE, regs->dbg_reset_warn_value)) \
+ CHIP_HELPER_DEF0(m, (u16, DBG_RESET_RESULT, regs->dbg_reset_result)) \
+ CHIP_HELPER_DEF0(m, (u16, WATCHDOG_DISABLE, regs->watchdog_disable)) \
+ CHIP_HELPER_DEF0(m, (u16, PROC_PC_SNOOP, regs->proc_pc_snoop)) \
+ CHIP_HELPER_DEF0(m, (u16, GBL_CHIP_VERSION, regs->gbl_chip_version)) \
+ CHIP_HELPER_DEF0(m, (u16, GBL_MISC_ENABLES, regs->gbl_misc_enables)) \
+ CHIP_HELPER_DEF0(m, (u16, XAP_PCH, regs->xap_pch)) \
+ CHIP_HELPER_DEF0(m, (u16, XAP_PCL, regs->xap_pcl)) \
+ CHIP_HELPER_DEF0(m, (u16, MAILBOX0, regs->mailbox0)) \
+ CHIP_HELPER_DEF0(m, (u16, MAILBOX1, regs->mailbox1)) \
+ CHIP_HELPER_DEF0(m, (u16, MAILBOX2, regs->mailbox2)) \
+ CHIP_HELPER_DEF0(m, (u16, MAILBOX3, regs->mailbox3)) \
+ CHIP_HELPER_DEF0(m, (u16, SDIO_HIP_HANDSHAKE, regs->sdio_hip_handshake)) \
+ 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, (CsrUint16, DATA_MEMORY_RAM_OFFSET, data_offset.ram)) \
+ 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_DEF0(m, (CsrInt32, HasRom, bools.has_rom)) \
CHIP_HELPER_DEF0(m, (CsrInt32, HasBt, bools.has_bt)) \
CHIP_HELPER_DEF0(m, (CsrInt32, HasWLan, bools.has_wlan)) \
- CHIP_HELPER_DEF1(m, (CsrUint16, WINDOW_ADDRESS, enum chip_helper_window_index, window)) \
- CHIP_HELPER_DEF1(m, (CsrUint16, WINDOW_SIZE, enum chip_helper_window_index, window)) \
- CHIP_HELPER_DEF1(m, (CsrUint16, MapAddress_SPI2HOST, CsrUint16, addr)) \
- CHIP_HELPER_DEF1(m, (CsrUint16, MapAddress_HOST2SPI, CsrUint16, addr)) \
+ CHIP_HELPER_DEF1(m, (u16, WINDOW_ADDRESS, enum chip_helper_window_index, window)) \
+ 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))
enum chip_helper_window_index window,
enum chip_helper_window_type type,
CsrUint32 offset,
- CsrUint16 *page, CsrUint16 *addr, CsrUint32 *len);
+ u16 *page, u16 *addr, CsrUint32 *len);
#ifdef __cplusplus
/* Close the extern "C" */
/* The default constructor assume a BC7 / UF105x series chip
and that the number given is the value of UNIFI_GBL_CHIP_VERSION
(0xFE81) */
- ChipHelper(CsrUint16 version);
+ ChipHelper(u16 version);
/* This returns the C interface magic token from a C++ instance. */
ChipDescript* GetDescript() const
void ClearVersion();
/* Load this class with data for a specific chip. */
- void GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81);
- void GetVersionUniFi(CsrUint16 version);
- void GetVersionBlueCore(chip_helper_bluecore_age age, CsrUint16 version);
+ void GetVersionAny(u16 from_FF9A, u16 from_FE81);
+ void GetVersionUniFi(u16 version);
+ void GetVersionBlueCore(chip_helper_bluecore_age age, u16 version);
void GetVersionSdio(u8 sdio_version);
/* Helpers to build the definitions of the member functions. */
CsrInt32 DecodeWindow(chip_helper_window_index window,
chip_helper_window_type type,
CsrUint32 offset,
- CsrUint16 &page, CsrUint16 &addr, CsrUint32 &len) const;
+ u16 &page, u16 &addr, CsrUint32 &len) const;
private:
ChipDescript *m_desc;
const struct chip_helper_init_values *vals;
};
-/* Just a (counted) CsrUint16 array */
+/* Just a (counted) u16 array */
struct data_array_t
{
CsrUint32 len;
- const CsrUint16 *vals;
+ const u16 *vals;
};
struct reset_prog_t
different host transports. */
struct chip_map_address_t
{
- CsrUint16 spi, host;
+ u16 spi, host;
};
struct map_array_t
struct chip_device_regs_per_transport_t
{
- CsrUint16 dbg_proc_select;
- CsrUint16 dbg_stop_status;
- CsrUint16 window1_page; /* PROG_PMEM1 or GW1 */
- CsrUint16 window2_page; /* PROG_PMEM2 or GW2 */
- CsrUint16 window3_page; /* SHARED or GW3 */
- CsrUint16 io_log_addr;
+ u16 dbg_proc_select;
+ u16 dbg_stop_status;
+ u16 window1_page; /* PROG_PMEM1 or GW1 */
+ u16 window2_page; /* PROG_PMEM2 or GW2 */
+ u16 window3_page; /* SHARED or GW3 */
+ u16 io_log_addr;
};
struct chip_device_regs_t
{
- CsrUint16 gbl_chip_version;
- CsrUint16 gbl_misc_enables;
- CsrUint16 dbg_emu_cmd;
+ u16 gbl_chip_version;
+ u16 gbl_misc_enables;
+ u16 dbg_emu_cmd;
struct chip_device_regs_per_transport_t host;
struct chip_device_regs_per_transport_t spi;
- CsrUint16 dbg_reset;
- CsrUint16 dbg_reset_value;
- CsrUint16 dbg_reset_warn;
- CsrUint16 dbg_reset_warn_value;
- CsrUint16 dbg_reset_result;
- CsrUint16 xap_pch;
- CsrUint16 xap_pcl;
- CsrUint16 proc_pc_snoop;
- CsrUint16 watchdog_disable;
- CsrUint16 mailbox0;
- CsrUint16 mailbox1;
- CsrUint16 mailbox2;
- CsrUint16 mailbox3;
- CsrUint16 sdio_host_int;
- CsrUint16 shared_io_interrupt;
- CsrUint16 sdio_hip_handshake;
- CsrUint16 coex_status; /* Allows WAPI detection */
+ u16 dbg_reset;
+ u16 dbg_reset_value;
+ u16 dbg_reset_warn;
+ u16 dbg_reset_warn_value;
+ u16 dbg_reset_result;
+ u16 xap_pch;
+ u16 xap_pcl;
+ u16 proc_pc_snoop;
+ u16 watchdog_disable;
+ u16 mailbox0;
+ u16 mailbox1;
+ u16 mailbox2;
+ u16 mailbox3;
+ u16 sdio_host_int;
+ u16 shared_io_interrupt;
+ u16 sdio_hip_handshake;
+ u16 coex_status; /* Allows WAPI detection */
};
/* If allowed is false then this window does not provide this
{
CsrInt32 allowed;
CsrUint32 page_shift;
- CsrUint16 page_offset;
+ u16 page_offset;
};
/* Each window has an address and size. These are obvious. It then
are unusable. */
struct window_info_t
{
- CsrUint16 address;
- CsrUint16 size;
- CsrUint16 blocked;
+ u16 address;
+ u16 size;
+ u16 blocked;
const struct window_shift_info_t *mode;
};
struct chip_version_t
{
CsrInt32 pre_bc7;
- CsrUint16 mask;
- CsrUint16 result;
+ u16 mask;
+ u16 result;
u8 sdio;
};
/* The offsets into the data address space of interesting things. */
struct
{
- CsrUint16 ram;
+ u16 ram;
/* maybe add shared / page tables? */
} data_offset;
CsrInt32 get_packed_struct_size(const u8 *buf);
CsrResult read_unpack_signal(const u8 *ptr, CSR_SIGNAL *sig);
-CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, CsrUint16 *sig_len);
+CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, u16 *sig_len);
#ifdef __cplusplus
}
static CsrResult _find_in_slut(card_t *card, symbol_t *psym, CsrUint32 *pslut)
{
CsrUint32 slut_address;
- CsrUint16 finger_print;
+ u16 finger_print;
CsrResult r;
CsrResult csrResult;
while (1)
{
- CsrUint16 id;
+ u16 id;
CsrUint32 obj;
r = unifi_card_read16(card, slut_address, &id);
static CsrResult safe_read_shared_location(card_t *card, CsrUint32 address, u8 *pdata)
{
CsrResult r;
- CsrUint16 limit = 1000;
+ u16 limit = 1000;
u8 b, b2;
*pdata = 0;
CsrInt32 data_len;
CsrUint32 write_len;
CsrResult r;
- const CsrUint16 buf_size = 2 * 1024;
+ const u16 buf_size = 2 * 1024;
offset = ptdl->dl_offset;
data_len = ptdl->dl_size;
{
CsrResult r;
CsrInt32 i;
- CsrUint16 loader_version;
- CsrUint16 handle;
+ u16 loader_version;
+ u16 handle;
CsrUint32 total_bytes;
/*
if (card->loader_led_mask)
{
r = unifi_card_write16(card, boot_ctrl_addr + 2,
- (CsrUint16)card->loader_led_mask);
+ (u16)card->loader_led_mask);
if (r != CSR_RESULT_SUCCESS)
{
unifi_error(card->ospriv, "Patch download: Failed to write LED mask\n");
/* Mini-coredump state */
typedef struct coredump_buf
{
- CsrUint16 count; /* serial number of dump */
+ u16 count; /* serial number of dump */
CsrTime timestamp; /* host's system time at capture */
CsrInt16 requestor; /* request: 0=auto dump, 1=manual */
- CsrUint16 chip_ver;
+ u16 chip_ver;
CsrUint32 fw_ver;
- CsrUint16 *zone[HIP_CDUMP_NUM_ZONES];
+ u16 *zone[HIP_CDUMP_NUM_ZONES];
struct coredump_buf *next; /* circular list */
struct coredump_buf *prev; /* 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 */
- CsrUint16 offset; /* 16-bit XAP word offset of zone in memory space */
- CsrUint16 length; /* Length of zone in XAP words */
+ u16 offset; /* 16-bit XAP word offset of zone in memory space */
+ u16 length; /* Length of zone in XAP words */
};
static CsrResult unifi_coredump_from_sdio(card_t *card, coredump_buffer *dump_buf);
static CsrResult unifi_coredump_read_zones(card_t *card, coredump_buffer *dump_buf);
-static CsrResult unifi_coredump_read_zone(card_t *card, CsrUint16 *zone,
+static CsrResult unifi_coredump_read_zone(card_t *card, u16 *zone,
const struct coredump_zone *def);
static CsrInt32 get_value_from_coredump(const coredump_buffer *dump,
- const unifi_coredump_space_t space, const CsrUint16 offset);
+ const unifi_coredump_space_t space, const u16 offset);
/* Table of chip memory zones we capture on mini-coredump */
static const struct coredump_zone zonedef_table[HIP_CDUMP_NUM_ZONES] = {
CsrResult unifi_coredump_capture(card_t *card, struct unifi_coredump_req *req)
{
CsrResult r = CSR_RESULT_SUCCESS;
- static CsrUint16 dump_seq_no = 1;
+ static u16 dump_seq_no = 1;
CsrTime time_of_capture;
func_enter();
*/
static CsrInt32 get_value_from_coredump(const coredump_buffer *coreDump,
const unifi_coredump_space_t space,
- const CsrUint16 offset_in_space)
+ const u16 offset_in_space)
{
CsrInt32 r = -1;
- CsrUint16 offset_in_zone;
+ u16 offset_in_zone;
CsrUint32 zone_end_offset;
CsrInt32 i;
const struct coredump_zone *def = &zonedef_table[0];
req->index, find_dump->count, i);
/* Find the appropriate entry in the buffer */
- req->value = get_value_from_coredump(find_dump, req->space, (CsrUint16)req->offset);
+ req->value = get_value_from_coredump(find_dump, req->space, (u16)req->offset);
if (req->value < 0)
{
r = CSR_WIFI_HIP_RESULT_RANGE; /* Un-captured register */
* It is assumed that the caller has already stopped the XAPs
* ---------------------------------------------------------------------------
*/
-static CsrResult unifi_coredump_read_zone(card_t *card, CsrUint16 *zonebuf, const struct coredump_zone *def)
+static CsrResult unifi_coredump_read_zone(card_t *card, u16 *zonebuf, const struct coredump_zone *def)
{
CsrResult r;
def->space, def->offset, def->length, def->gp, def->cpu);
/* Read on-chip RAM (byte-wise) */
- r = unifi_card_readn(card, def->gp, zonebuf, (CsrUint16)(def->length * 2));
+ r = unifi_card_readn(card, def->gp, zonebuf, (u16)(def->length * 2));
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
{
goto done;
*/
static CsrResult unifi_coredump_from_sdio(card_t *card, coredump_buffer *dump_buf)
{
- CsrUint16 val;
+ u16 val;
CsrResult r;
CsrUint32 sdio_addr;
coredump_buffer* new_coredump_node(void *ospriv, coredump_buffer *prevnode)
{
coredump_buffer *newnode = NULL;
- CsrUint16 *newzone = NULL;
+ u16 *newzone = NULL;
CsrInt32 i;
CsrUint32 zone_size;
/* Allocate chip memory zone capture buffers */
for (i = 0; i < HIP_CDUMP_NUM_ZONES; i++)
{
- zone_size = sizeof(CsrUint16) * zonedef_table[i].length;
- newzone = (CsrUint16 *)CsrMemAlloc(zone_size);
+ zone_size = sizeof(u16) * zonedef_table[i].length;
+ newzone = (u16 *)CsrMemAlloc(zone_size);
newnode->zone[i] = newzone;
if (newzone != NULL)
{
* free for capturing.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_coredump_init(card_t *card, CsrUint16 num_dump_buffers)
+CsrResult unifi_coredump_init(card_t *card, u16 num_dump_buffers)
{
#ifndef UNIFI_DISABLE_COREDUMP
void *ospriv = card->ospriv;
CsrInt32 get_packed_struct_size(const u8 *buf)
{
CsrInt32 size = 0;
- CsrUint16 sig_id;
+ u16 sig_id;
sig_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(buf);
* CSR_WIFI_HIP_RESULT_INVALID_VALUE if the ID of signal was not recognised.
* ---------------------------------------------------------------------------
*/
-CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, CsrUint16 *sig_len)
+CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, u16 *sig_len)
{
CsrInt16 index = 0;
const bulk_data_param_t *bulkdata,
q_t *sigq, CsrUint32 priority_q, CsrUint32 run_bh)
{
- CsrUint16 i, data_slot_size;
+ u16 i, data_slot_size;
card_signal_t *csptr;
CsrInt16 qe;
CsrResult r;
csptr = CSR_WIFI_HIP_Q_SLOT_DATA(sigq, qe);
/* Make up the card_signal struct */
- csptr->signal_length = (CsrUint16)siglen;
+ csptr->signal_length = (u16)siglen;
CsrMemCpy((void *)csptr->sigbuf, (void *)sigptr, siglen);
for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; ++i)
const bulk_data_param_t *bulkdata)
{
q_t *sig_soft_q;
- CsrUint16 signal_id;
+ u16 signal_id;
CsrResult r;
CsrUint32 run_bh;
CsrUint32 priority_q;
*/
if (signal_id == CSR_MA_PACKET_REQUEST_ID)
{
- CsrUint16 frame_priority;
+ u16 frame_priority;
if (card->periodic_wake_mode == UNIFI_PERIODIC_WAKE_HOST_ENABLED)
{
CsrResult unifi_send_resources_available(card_t *card, const u8 *sigptr)
{
q_t *sig_soft_q;
- CsrUint16 signal_id = GET_SIGNAL_ID(sigptr);
+ u16 signal_id = GET_SIGNAL_ID(sigptr);
/*
* If the signal is a CSR_MA_PACKET_REQUEST ,
*/
if (signal_id == CSR_MA_PACKET_REQUEST_ID)
{
- CsrUint16 frame_priority;
+ u16 frame_priority;
CsrUint32 priority_q;
/* Map the frame priority to a traffic queue index. */
}
-CsrUint32 SigGetFilterPos(CsrUint16 aSigID)
+CsrUint32 SigGetFilterPos(u16 aSigID)
{
switch (aSigID)
{
typedef CsrInt16 csr_place_holding_type;
-typedef CsrUint16 CSR_ASSOCIATION_ID;
+typedef u16 CSR_ASSOCIATION_ID;
-typedef CsrUint16 CSR_AUTONOMOUS_SCAN_ID;
+typedef u16 CSR_AUTONOMOUS_SCAN_ID;
-typedef CsrUint16 CSR_BEACON_PERIODS;
+typedef u16 CSR_BEACON_PERIODS;
-typedef CsrUint16 CSR_BLACKOUT_ID;
+typedef u16 CSR_BLACKOUT_ID;
typedef enum CSR_BLACKOUT_SOURCE
{
CSR_BOOT_LOADER_IMAGE_3 = 0x13
} CSR_BOOT_LOADER_OPERATION;
-typedef CsrUint16 CSR_CAPABILITY_INFORMATION;
+typedef u16 CSR_CAPABILITY_INFORMATION;
-typedef CsrUint16 CSR_CHANNEL_STARTING_FACTOR;
+typedef u16 CSR_CHANNEL_STARTING_FACTOR;
typedef CsrUint32 CSR_CIPHER_SUITE_SELECTOR;
CSR_BT_PROCESSOR_ROM = 0x32
} CSR_MEMORY_SPACE;
-typedef CsrUint16 CSR_MICROSECONDS16;
+typedef u16 CSR_MICROSECONDS16;
typedef CsrUint32 CSR_MICROSECONDS32;
-typedef CsrUint16 CSR_NATURAL16;
+typedef u16 CSR_NATURAL16;
typedef enum CSR_PS_SCHEME
{
CSR_PFM_OPT_IN = 0x0003
} CSR_PACKET_FILTER_MODE;
-typedef CsrUint16 CSR_PERIODIC_ID;
+typedef u16 CSR_PERIODIC_ID;
typedef enum CSR_PERIODIC_SCHEDULING_MODE
{
CSR_DEBUG_GENERIC_INDICATION_ID = 0x080b
} CSR_SIGNAL_ID;
-typedef CsrUint16 CSR_SIMPLE_POINTER;
+typedef u16 CSR_SIMPLE_POINTER;
-typedef CsrUint16 CSR_STARTING_SEQUENCE_NUMBER;
+typedef u16 CSR_STARTING_SEQUENCE_NUMBER;
typedef enum CSR_SYMBOL_ID
{
u8 x[8];
} CSR_TSF_TIME;
-typedef CsrUint16 CSR_TIME_UNITS;
+typedef u16 CSR_TIME_UNITS;
typedef enum CSR_TRANSMISSION_CONTROL
{
CSR_TX_REJECTED_DTIM_STARTED = 0x0010
} CSR_TRANSMISSION_STATUS;
-typedef CsrUint16 CSR_TRIGGER_ID;
+typedef u16 CSR_TRIGGER_ID;
-typedef CsrUint16 CSR_TRIGGERED_ID;
+typedef u16 CSR_TRIGGERED_ID;
typedef enum CSR_HIP_VERSIONS
{
CSR_HIP_VERSION = 0x0900
} CSR_HIP_VERSIONS;
-typedef CsrUint16 CSR_BUFFER_HANDLE;
+typedef u16 CSR_BUFFER_HANDLE;
-typedef CsrUint16 CSR_CHANNEL_NUMBER;
+typedef u16 CSR_CHANNEL_NUMBER;
typedef struct CSR_DATA_REFERENCE
{
- CsrUint16 SlotNumber;
- CsrUint16 DataLength;
+ u16 SlotNumber;
+ u16 DataLength;
} CSR_DATAREF;
-typedef CsrUint16 CSR_DIALOG_TOKEN;
+typedef u16 CSR_DIALOG_TOKEN;
typedef struct CSR_GENERIC_POINTER
{
CSR_DIALOG_TOKEN DialogToken;
} CSR_MLME_STOP_MEASURE_REQUEST;
-typedef CsrUint16 CSR_PROCESS_ID;
+typedef u16 CSR_PROCESS_ID;
-typedef CsrUint16 CSR_RATE;
+typedef u16 CSR_RATE;
-typedef CsrUint16 CSR_SEQUENCE_NUMBER;
+typedef u16 CSR_SEQUENCE_NUMBER;
typedef struct CSR_SIGNAL_PRIMITIVE_HEADER
{
CSR_PROCESS_ID SenderProcessId;
} CSR_SIGNAL_PRIMITIVE_HEADER;
-typedef CsrUint16 CSR_TRAFFIC_WINDOW;
+typedef u16 CSR_TRAFFIC_WINDOW;
-typedef CsrUint16 CSR_VIF_IDENTIFIER;
+typedef u16 CSR_VIF_IDENTIFIER;
typedef struct CSR_DEBUG_GENERIC_CONFIRM
{
#define SIG_FILTER_SIZE 6
-CsrUint32 SigGetFilterPos(CsrUint16 aSigID);
+CsrUint32 SigGetFilterPos(u16 aSigID);
#ifdef __cplusplus
}
const u8 *sta_macaddr)
{
ta_data_t *tad = &card->ta_sampling;
- CsrUint16 proto;
- CsrUint16 source_port, dest_port;
+ u16 proto;
+ u16 source_port, dest_port;
CsrWifiMacAddress srcAddress;
CsrUint32 snap_hdr, oui_hdr;
const u8 *saddr,
const u8 *sta_macaddr,
CsrUint32 timestamp,
- CsrUint16 rate)
+ u16 rate)
{
ta_data_t *tad = &card->ta_sampling;
enum ta_frame_identity identity;
*/
void unifi_ta_classification(card_t *card,
CsrWifiRouterCtrlTrafficType traffic_type,
- CsrUint16 period)
+ u16 period)
{
unifi_trace(card->ospriv, UDBG3,
"Changed current ta classification to: %d\n", traffic_type);
typedef struct ta_data
{
/* Current packet filter configuration */
- CsrUint16 packet_filter;
+ u16 packet_filter;
/* Current packet custom filter configuration */
CsrWifiRouterCtrlTrafficFilter custom_filter;
{
CsrCharString *p = str;
sdio_config_data_t *cfg;
- CsrUint16 i, n;
+ u16 i, n;
CsrInt32 remaining = *remain;
CsrInt32 written;
#ifdef CSR_UNSAFE_SDIO_ACCESS
i = n = 0;
written = CsrSnprintf(p, remaining, "Chip ID %u\n",
- (CsrUint16)card->chip_id);
+ (u16)card->chip_id);
UNIFI_SNPRINTF_RET(p, remaining, written);
written = CsrSnprintf(p, remaining, "Chip Version %04X\n",
card->chip_version);
/* Added by protocol version 0x0001 */
written = CsrSnprintf(p, remaining, "overlay_size %u\n",
- (CsrUint16)cfg->overlay_size);
+ (u16)cfg->overlay_size);
UNIFI_SNPRINTF_RET(p, remaining, written);
/* Added by protocol version 0x0300 */
UNIFI_SNPRINTF_RET(p, remaining, written);
written = CsrSnprintf(p, remaining, "fhsr: %u\n",
- (CsrUint16)card->from_host_signals_r);
+ (u16)card->from_host_signals_r);
UNIFI_SNPRINTF_RET(p, remaining, written);
written = CsrSnprintf(p, remaining, "fhsw: %u\n",
- (CsrUint16)card->from_host_signals_w);
+ (u16)card->from_host_signals_w);
UNIFI_SNPRINTF_RET(p, remaining, written);
written = CsrSnprintf(p, remaining, "thsr: %u\n",
- (CsrUint16)card->to_host_signals_r);
+ (u16)card->to_host_signals_r);
UNIFI_SNPRINTF_RET(p, remaining, written);
written = CsrSnprintf(p, remaining, "thsw: %u\n",
- (CsrUint16)card->to_host_signals_w);
+ (u16)card->to_host_signals_w);
UNIFI_SNPRINTF_RET(p, remaining, written);
written = CsrSnprintf(p, remaining,
"fh buffer contains: %u signals, %u bytes\n",
for (i = 0; i < n && card->from_host_data; i++)
{
written = CsrSnprintf(p, remaining, " %u",
- (CsrUint16)card->from_host_data[i].bd.data_length);
+ (u16)card->from_host_data[i].bd.data_length);
UNIFI_SNPRINTF_RET(p, remaining, written);
}
written = CsrSnprintf(p, remaining, "\n");
for (i = 0; i < n && card->to_host_data; i++)
{
written = CsrSnprintf(p, remaining, " %u",
- (CsrUint16)card->to_host_data[i].data_length);
+ (u16)card->to_host_data[i].data_length);
UNIFI_SNPRINTF_RET(p, remaining, written);
}
/* Structure of an entry in the Symbol Look Up Table (SLUT). */
typedef struct _symbol
{
- CsrUint16 id;
+ u16 id;
CsrUint32 obj;
} symbol_t;
*/
typedef struct _card_info
{
- CsrUint16 chip_id;
- CsrUint16 chip_version;
+ u16 chip_id;
+ u16 chip_version;
CsrUint32 fw_build;
- CsrUint16 fw_hip_version;
+ u16 fw_hip_version;
CsrUint32 sdio_block_size;
} card_info_t;
const u8 *saddr,
const u8 *sta_macaddr,
CsrUint32 timestamp,
- CsrUint16 rate);
+ u16 rate);
/**
* Notify the HIP core lib for a detected Traffic Classification.
*/
void unifi_ta_classification(card_t *card,
CsrWifiRouterCtrlTrafficType traffic_type,
- CsrUint16 period);
+ u16 period);
#endif
/**
CsrResult unifi_card_hard_reset(card_t *card);
-CsrResult unifi_card_readn(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len);
-CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, CsrUint16 *pdata);
-CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, CsrUint16 data);
+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);
enum unifi_dbg_processors_select
* @ingroup upperedge
*/
CsrResult unifi_reque_ma_packet_request(void *ospriv, CsrUint32 host_tag,
- CsrUint16 status,
+ u16 status,
bulk_data_desc_t *bulkDataDesc);
#endif
typedef struct
{
- CsrUint16 free_fh_sig_queue_slots[UNIFI_NO_OF_TX_QS];
- CsrUint16 free_fh_bulkdata_slots;
- CsrUint16 free_fh_fw_slots;
+ u16 free_fh_sig_queue_slots[UNIFI_NO_OF_TX_QS];
+ u16 free_fh_bulkdata_slots;
+ u16 free_fh_fw_slots;
} unifi_HipQosInfo;
void unifi_get_hip_qos_info(card_t *card, unifi_HipQosInfo *hipqosinfo);
/* Functions to lookup bulk data command names. */
-const CsrCharString* lookup_bulkcmd_name(CsrUint16 id);
+const CsrCharString* lookup_bulkcmd_name(u16 id);
/* Function to log HIP's global debug buffer */
#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
void unifi_debug_buf_dump(void);
void unifi_debug_log_to_buf(const CsrCharString *fmt, ...);
-void unifi_debug_hex_to_buf(const CsrCharString *buff, CsrUint16 length);
+void unifi_debug_hex_to_buf(const CsrCharString *buff, u16 length);
#endif
/* Mini-coredump utility functions */
CsrResult unifi_coredump_get_value(card_t *card, struct unifi_coredump_req *req);
CsrResult unifi_coredump_capture(card_t *card, struct unifi_coredump_req *req);
CsrResult unifi_coredump_request_at_next_reset(card_t *card, s8 enable);
-CsrResult unifi_coredump_init(card_t *card, CsrUint16 num_dump_buffers);
+CsrResult unifi_coredump_init(card_t *card, u16 num_dump_buffers);
void unifi_coredump_free(card_t *card);
#ifdef __cplusplus
{ 15, "Padding" }
};
-const CsrCharString* lookup_bulkcmd_name(CsrUint16 id)
+const CsrCharString* lookup_bulkcmd_name(u16 id)
{
if (id < 9)
{
xbv_container new_cont, CsrUint32 ioff);
static CsrUint32 write_uint16(void *buf, const CsrUint32 offset,
- const CsrUint16 val);
+ const u16 val);
static CsrUint32 write_uint32(void *buf, const CsrUint32 offset,
const CsrUint32 val);
static CsrUint32 write_bytes(void *buf, const CsrUint32 offset,
static CsrUint32 write_chunk(void *buf, const CsrUint32 offset,
const CsrCharString *tag_str,
const CsrUint32 payload_len);
-static CsrUint16 calc_checksum(void *buf, const CsrUint32 offset,
+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_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 CsrUint16 len);
+ 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,
/* Fill in the VMEQ */
vmeq->addr = temp[0];
- vmeq->mask = (CsrUint16)temp[1];
- vmeq->value = (CsrUint16)temp[2];
+ vmeq->mask = (u16)temp[1];
+ vmeq->value = (u16)temp[2];
}
else if (TAG_EQ(tag.t_name, "FWID"))
{
} /* read_uint() */
-static CsrUint32 write_uint16(void *buf, const CsrUint32 offset, const CsrUint16 val)
+static CsrUint32 write_uint16(void *buf, const CsrUint32 offset, const u16 val)
{
u8 *dst = (u8 *)buf + offset;
*dst++ = (u8)(val & 0xff); /* LSB first */
*dst = (u8)(val >> 8);
- return sizeof(CsrUint16);
+ return sizeof(u16);
}
static CsrUint32 write_uint32(void *buf, const CsrUint32 offset, const CsrUint32 val)
{
- (void)write_uint16(buf, offset + 0, (CsrUint16)(val & 0xffff));
- (void)write_uint16(buf, offset + 2, (CsrUint16)(val >> 16));
+ (void)write_uint16(buf, offset + 0, (u16)(val & 0xffff));
+ (void)write_uint16(buf, offset + 2, (u16)(val >> 16));
return sizeof(CsrUint32);
}
}
-static CsrUint16 calc_checksum(void *buf, const CsrUint32 offset, const CsrUint32 bytes_len)
+static u16 calc_checksum(void *buf, const CsrUint32 offset, const CsrUint32 bytes_len)
{
CsrUint32 i;
u8 *src = (u8 *)buf + offset;
- CsrUint16 sum = 0;
- CsrUint16 val;
+ u16 sum = 0;
+ u16 val;
for (i = 0; i < bytes_len / 2; i++)
{
/* Contents copied to file is LE, host might not be */
- val = (CsrUint16) * src++; /* LSB */
- val += (CsrUint16)(*src++) << 8; /* MSB */
+ val = (u16) * src++; /* LSB */
+ val += (u16)(*src++) << 8; /* MSB */
sum += val;
}
#define UF_MEMPUT_MAC 0x0000
#define UF_MEMPUT_PHY 0x1000
-static CsrUint32 write_patchcmd(void *buf, const CsrUint32 offset, const CsrUint32 dst_genaddr, const CsrUint16 len)
+static CsrUint32 write_patchcmd(void *buf, const CsrUint32 offset, const CsrUint32 dst_genaddr, const u16 len)
{
CsrUint32 written = 0;
CsrUint32 region = (dst_genaddr >> 28);
- CsrUint16 cmd_and_len = UF_MEMPUT_MAC;
+ u16 cmd_and_len = UF_MEMPUT_MAC;
if (region == UF_REGION_PHY)
{
written += write_uint16(buf, offset + written, cmd_and_len);
/* Write the destination generic address */
- written += write_uint16(buf, offset + written, (CsrUint16)(dst_genaddr >> 16));
- written += write_uint16(buf, offset + written, (CsrUint16)(dst_genaddr & 0xffff));
+ written += write_uint16(buf, offset + written, (u16)(dst_genaddr >> 16));
+ written += write_uint16(buf, offset + written, (u16)(dst_genaddr & 0xffff));
/* The data payload should be appended to the command */
return written;
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 */
- CsrUint16 csum;
+ 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 */
csum_start_offs = offset + written;
/* Patch-chunk header: fw_id. Note that this is in XAP word order */
- written += write_uint16(buf, offset + written, (CsrUint16)(fw_id >> 16));
- written += write_uint16(buf, offset + written, (CsrUint16)(fw_id & 0xffff));
+ written += write_uint16(buf, offset + written, (u16)(fw_id >> 16));
+ written += write_uint16(buf, offset + written, (u16)(fw_id & 0xffff));
/* Patch-chunk header: section length in uint16s */
- written += write_uint16(buf, offset + written, (CsrUint16)(sec_len / 2));
+ written += write_uint16(buf, offset + written, (u16)(sec_len / 2));
/* Write the appropriate patch command for the data's destination ptr */
- written += write_patchcmd(buf, offset + written, dl_addr, (CsrUint16)(sec_data_len / 2));
+ written += write_patchcmd(buf, offset + written, dl_addr, (u16)(sec_data_len / 2));
/* Write the data itself (limited to the max chunk length) */
if (readfn(NULL, (void *)dlpriv, dl_offs, fw_buf, sec_data_len) < 0)
fw_buf,
sec_data_len);
- /* CsrUint16 checksum calculated over data written */
+ /* u16 checksum calculated over data written */
csum = calc_checksum(buf, csum_start_offs, written - (csum_start_offs - offset));
written += write_uint16(buf, offset + written, csum);
static CsrUint32 write_reset_ptdl(void *buf, const CsrUint32 offset, const xbv1_t *fwinfo, CsrUint32 fw_id)
{
CsrUint32 written = 0;
- CsrUint16 csum;
+ u16 csum;
CsrUint32 csum_start_offs; /* first offset to include in checksum */
CsrUint32 sec_len; /* section data + header byte count */
csum_start_offs = offset + written;
/* Patch-chunk header: fw_id. Note that this is in XAP word order */
- written += write_uint16(buf, offset + written, (CsrUint16)(fw_id >> 16));
- written += write_uint16(buf, offset + written, (CsrUint16)(fw_id & 0xffff));
+ written += write_uint16(buf, offset + written, (u16)(fw_id >> 16));
+ written += write_uint16(buf, offset + written, (u16)(fw_id & 0xffff));
/* Patch-chunk header: section length in uint16s */
- written += write_uint16(buf, offset + written, (CsrUint16)(sec_len / 2));
+ written += write_uint16(buf, offset + written, (u16)(sec_len / 2));
/*
* Restart addresses to be executed on subsequent loader restart command.
written += write_uint16(buf, offset + written, (UF_PHY_START_VEC >> 16));
written += write_uint16(buf, offset + written, (UF_PHY_START_VEC & 0xffff));
- /* CsrUint16 checksum calculated over data written */
+ /* u16 checksum calculated over data written */
csum = calc_checksum(buf, csum_start_offs, written - (csum_start_offs - offset));
written += write_uint16(buf, offset + written, csum);
return -1;
}
- slut[count].id = (CsrUint16)id;
+ slut[count].id = (u16)id;
slut[count].obj = obj;
count++;
}
struct VMEQ
{
CsrUint32 addr;
- CsrUint16 mask;
- CsrUint16 value;
+ u16 mask;
+ u16 value;
};
struct VAND
* Allocates and fills in a message with the signature CsrWifiEvent
*
*----------------------------------------------------------------------------*/
-CsrWifiFsmEvent* CsrWifiEvent_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src);
+CsrWifiFsmEvent* CsrWifiEvent_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src);
typedef struct
{
* Allocates and fills in a message with the signature CsrWifiEventCsrUint8
*
*----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint8* CsrWifiEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, u8 value);
+CsrWifiEventCsrUint8* CsrWifiEventCsrUint8_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src, u8 value);
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 value;
+ u16 value;
} CsrWifiEventCsrUint16;
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrWifiEventCsrUint16
*
*----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint16* CsrWifiEventCsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint16 value);
+CsrWifiEventCsrUint16* CsrWifiEventCsrUint16_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src, u16 value);
typedef struct
{
* Allocates and fills in a message with the signature CsrWifiEventCsrUint32
*
*----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint32* CsrWifiEventCsrUint32_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint32 value);
+CsrWifiEventCsrUint32* CsrWifiEventCsrUint32_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint32 value);
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 value16;
+ u16 value16;
u8 value8;
} CsrWifiEventCsrUint16CsrUint8;
* Allocates and fills in a message with the signature CsrWifiEventCsrUint16CsrUint8
*
*----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint16CsrUint8* CsrWifiEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint16 value16, u8 value8);
+CsrWifiEventCsrUint16CsrUint8* CsrWifiEventCsrUint16CsrUint8_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src, u16 value16, u8 value8);
#ifdef __cplusplus
}
#endif
-void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, CsrUint16 v);
+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 CsrUint16DesBigEndian(CsrUint16 *v, u8 *buffer, CsrSize *offset);
+void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset);
void CsrUint24DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset);
void CsrUint32DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset);
{ 0, NULL, NULL, NULL, NULL },
};
-CsrMsgConvMsgEntry* CsrWifiNmeApConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+CsrMsgConvMsgEntry* CsrWifiNmeApConverterLookup(CsrMsgConvMsgEntry *ce, u16 msgType)
{
if (msgType & CSR_PRIM_UPSTREAM)
{
- CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT;
+ u16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT;
if (idx < (CSR_WIFI_NME_AP_PRIM_UPSTREAM_COUNT + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT) &&
csrwifinmeap_conv_lut[idx].msgType == msgType)
{
* eventClass: only the value CSR_WIFI_NME_AP_PRIM will be handled
* message: the message to free
*----------------------------------------------------------------------------*/
-void CsrWifiNmeApFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiNmeApFreeDownstreamMessageContents(u16 eventClass, void *message)
{
if (eventClass != CSR_WIFI_NME_AP_PRIM)
{
break;
}
{
- CsrUint16 i3;
+ u16 i3;
for (i3 = 0; i3 < p->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
{
CsrPmemFree(p->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel);
* eventClass: only the value CSR_WIFI_NME_AP_PRIM will be handled
* message: the message to free
*----------------------------------------------------------------------------*/
-void CsrWifiNmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiNmeApFreeUpstreamMessageContents(u16 eventClass, void *message)
{
if (eventClass != CSR_WIFI_NME_AP_PRIM)
{
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_NME_AP upstream message
*----------------------------------------------------------------------------*/
-void CsrWifiNmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiNmeApFreeUpstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* CsrWifiNmeApFreeDownstreamMessageContents
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_NME_AP downstream message
*----------------------------------------------------------------------------*/
-void CsrWifiNmeApFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiNmeApFreeDownstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* Enum to string functions
*******************************************************************************/
typedef struct
{
- CsrUint16 apGroupkeyTimeout;
+ u16 apGroupkeyTimeout;
CsrBool apStrictGtkRekey;
- CsrUint16 apGmkTimeout;
- CsrUint16 apResponseTimeout;
+ u16 apGmkTimeout;
+ u16 apResponseTimeout;
u8 apRetransLimit;
} CsrWifiNmeApConfig;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeWpsDpid selectedDevicePasswordId;
CsrWifiSmeWpsConfigType selectedConfigMethod;
u8 pin[8];
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeApType apType;
CsrBool cloakSsid;
CsrWifiSsid ssid;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiNmeApStopReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress staMacAddress;
CsrBool keepBlocking;
} CsrWifiNmeApStaRemoveReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiNmeApWpsRegisterCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSsid ssid;
} CsrWifiNmeApStartCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiNmeApStopCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeApType apType;
CsrResult status;
} CsrWifiNmeApStopInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeMediaStatus mediaStatus;
CsrWifiMacAddress peerMacAddress;
CsrWifiMacAddress peerDeviceAddress;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 104) */
- bufferSize += 2; /* CsrUint16 primitive->apConfig.apGroupkeyTimeout */
+ bufferSize += 2; /* u16 primitive->apConfig.apGroupkeyTimeout */
bufferSize += 1; /* CsrBool primitive->apConfig.apStrictGtkRekey */
- bufferSize += 2; /* CsrUint16 primitive->apConfig.apGmkTimeout */
- bufferSize += 2; /* CsrUint16 primitive->apConfig.apResponseTimeout */
+ bufferSize += 2; /* u16 primitive->apConfig.apGmkTimeout */
+ bufferSize += 2; /* u16 primitive->apConfig.apResponseTimeout */
bufferSize += 1; /* u8 primitive->apConfig.apRetransLimit */
bufferSize += 1; /* CsrWifiSmeApPhySupportMask primitive->apMacConfig.phySupportedBitmap */
- bufferSize += 2; /* CsrUint16 primitive->apMacConfig.beaconInterval */
+ bufferSize += 2; /* u16 primitive->apMacConfig.beaconInterval */
bufferSize += 1; /* u8 primitive->apMacConfig.dtimPeriod */
- bufferSize += 2; /* CsrUint16 primitive->apMacConfig.maxListenInterval */
+ bufferSize += 2; /* u16 primitive->apMacConfig.maxListenInterval */
bufferSize += 1; /* u8 primitive->apMacConfig.supportedRatesCount */
bufferSize += 20; /* u8 primitive->apMacConfig.supportedRates[20] */
bufferSize += 1; /* CsrWifiSmePreambleType primitive->apMacConfig.preamble */
bufferSize += 1; /* CsrWifiSmeCtsProtectionType primitive->apMacConfig.ctsProtectionType */
bufferSize += 1; /* CsrBool primitive->apMacConfig.wmmEnabled */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].cwMin */
bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].cwMax */
bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].aifs */
- bufferSize += 2; /* CsrUint16 primitive->apMacConfig.wmmApParams[i2].txopLimit */
+ bufferSize += 2; /* u16 primitive->apMacConfig.wmmApParams[i2].txopLimit */
bufferSize += 1; /* CsrBool primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory */
}
}
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].cwMin */
bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].cwMax */
bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].aifs */
- bufferSize += 2; /* CsrUint16 primitive->apMacConfig.wmmApBcParams[i2].txopLimit */
+ bufferSize += 2; /* u16 primitive->apMacConfig.wmmApBcParams[i2].txopLimit */
bufferSize += 1; /* CsrBool primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory */
}
}
bufferSize += 1; /* CsrWifiSmeApAccessType primitive->apMacConfig.accessType */
bufferSize += 1; /* u8 primitive->apMacConfig.macAddressListCount */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
{
bufferSize += 6; /* u8 primitive->apMacConfig.macAddressList[i2].a[6] */
CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apGroupkeyTimeout);
+ CsrUint16Ser(ptr, len, (u16) primitive->apConfig.apGroupkeyTimeout);
CsrUint8Ser(ptr, len, (u8) primitive->apConfig.apStrictGtkRekey);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apGmkTimeout);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apResponseTimeout);
+ CsrUint16Ser(ptr, len, (u16) primitive->apConfig.apGmkTimeout);
+ CsrUint16Ser(ptr, len, (u16) primitive->apConfig.apResponseTimeout);
CsrUint8Ser(ptr, len, (u8) primitive->apConfig.apRetransLimit);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.phySupportedBitmap);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.beaconInterval);
+ CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.beaconInterval);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.dtimPeriod);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.maxListenInterval);
+ CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.maxListenInterval);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.supportedRatesCount);
- CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.supportedRates, ((CsrUint16) (20)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.supportedRates, ((u16) (20)));
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.preamble);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.shortSlotTimeEnabled);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.ctsProtectionType);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmEnabled);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].cwMin);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].cwMax);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].aifs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.wmmApParams[i2].txopLimit);
+ CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.wmmApParams[i2].txopLimit);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory);
}
}
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].cwMin);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].cwMax);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].aifs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.wmmApBcParams[i2].txopLimit);
+ CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.wmmApBcParams[i2].txopLimit);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory);
}
}
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.accessType);
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.macAddressListCount);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.macAddressList[i2].a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.macAddressList[i2].a, ((u16) (6)));
}
}
CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.greenfieldSupported);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->apConfig.apGroupkeyTimeout, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->apConfig.apGroupkeyTimeout, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apConfig.apStrictGtkRekey, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->apConfig.apGmkTimeout, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->apConfig.apResponseTimeout, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->apConfig.apGmkTimeout, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->apConfig.apResponseTimeout, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apConfig.apRetransLimit, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.phySupportedBitmap, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.beaconInterval, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->apMacConfig.beaconInterval, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.dtimPeriod, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.maxListenInterval, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->apMacConfig.maxListenInterval, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.supportedRatesCount, buffer, &offset);
- CsrMemCpyDes(primitive->apMacConfig.supportedRates, buffer, &offset, ((CsrUint16) (20)));
+ CsrMemCpyDes(primitive->apMacConfig.supportedRates, buffer, &offset, ((u16) (20)));
CsrUint8Des((u8 *) &primitive->apMacConfig.preamble, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.shortSlotTimeEnabled, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.ctsProtectionType, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.wmmEnabled, buffer, &offset);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].cwMin, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].cwMax, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].aifs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.wmmApParams[i2].txopLimit, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->apMacConfig.wmmApParams[i2].txopLimit, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory, buffer, &offset);
}
}
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMin, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMax, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].aifs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.wmmApBcParams[i2].txopLimit, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->apMacConfig.wmmApBcParams[i2].txopLimit, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory, buffer, &offset);
}
}
primitive->apMacConfig.macAddressList = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->apMacConfig.macAddressListCount);
}
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
{
- CsrMemCpyDes(primitive->apMacConfig.macAddressList[i2].a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->apMacConfig.macAddressList[i2].a, buffer, &offset, ((u16) (6)));
}
}
CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.greenfieldSupported, buffer, &offset);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiSmeWpsDpid primitive->selectedDevicePasswordId */
bufferSize += 2; /* CsrWifiSmeWpsConfigType primitive->selectedConfigMethod */
bufferSize += 8; /* u8 primitive->pin[8] */
CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->selectedDevicePasswordId);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->selectedConfigMethod);
- CsrMemCpySer(ptr, len, (const void *) primitive->pin, ((CsrUint16) (8)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->selectedDevicePasswordId);
+ CsrUint16Ser(ptr, len, (u16) primitive->selectedConfigMethod);
+ CsrMemCpySer(ptr, len, (const void *) primitive->pin, ((u16) (8)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->selectedDevicePasswordId, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->selectedConfigMethod, buffer, &offset);
- CsrMemCpyDes(primitive->pin, buffer, &offset, ((CsrUint16) (8)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->selectedDevicePasswordId, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->selectedConfigMethod, buffer, &offset);
+ CsrMemCpyDes(primitive->pin, buffer, &offset, ((u16) (8)));
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 112) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeApType primitive->apType */
bufferSize += 1; /* CsrBool primitive->cloakSsid */
bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
{
case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
- bufferSize += 2; /* CsrUint16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode */
+ bufferSize += 2; /* u16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode */
bufferSize += 32; /* u8 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk[32] */
break;
case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
- bufferSize += 2; /* CsrUint16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode */
+ bufferSize += 2; /* u16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode */
bufferSize += (primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase?CsrStrLen(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase) : 0) + 1; /* CsrCharString* primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase (0 byte len + 1 for NULL Term) */
break;
default:
bufferSize += 3; /* u8 primitive->p2pGoParam.operatingChanList.country[3] */
bufferSize += 1; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryListCount */
{
- CsrUint16 i3;
+ u16 i3;
for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
{
bufferSize += 1; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass */
CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->apType);
CsrUint8Ser(ptr, len, (u8) primitive->cloakSsid);
- CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
CsrUint8Ser(ptr, len, (u8) primitive->ifIndex);
CsrUint8Ser(ptr, len, (u8) primitive->channel);
case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType);
CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey);
- CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, ((CsrUint16) (13)));
- CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, ((CsrUint16) (13)));
- CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, ((CsrUint16) (13)));
- CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, ((CsrUint16) (13)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, ((u16) (13)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, ((u16) (13)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, ((u16) (13)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, ((u16) (13)));
break;
case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType);
CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey);
- CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, ((CsrUint16) (5)));
- CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, ((CsrUint16) (5)));
- CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, ((CsrUint16) (5)));
- CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, ((CsrUint16) (5)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, ((u16) (5)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, ((u16) (5)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, ((u16) (5)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, ((u16) (5)));
break;
default:
break;
break;
case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities);
+ CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities);
+ CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities);
CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase);
switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
{
case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode);
- CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, ((CsrUint16) (32)));
+ CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode);
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, ((u16) (32)));
break;
case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode);
+ CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode);
CsrCharStringSer(ptr, len, primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase);
break;
default:
}
CsrUint8Ser(ptr, len, (u8) primitive->maxConnections);
CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.groupCapability);
- CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.country, ((CsrUint16) (3)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.country, ((u16) (3)));
CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryListCount);
{
- CsrUint16 i3;
+ u16 i3;
for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
{
CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass);
CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, ((CsrUint16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, ((u16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
}
}
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apType, buffer, &offset);
CsrUint8Des((u8 *) &primitive->cloakSsid, buffer, &offset);
- CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
CsrUint8Des((u8 *) &primitive->ifIndex, buffer, &offset);
CsrUint8Des((u8 *) &primitive->channel, buffer, &offset);
case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey, buffer, &offset);
- CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, buffer, &offset, ((CsrUint16) (13)));
- CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, buffer, &offset, ((CsrUint16) (13)));
- CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, buffer, &offset, ((CsrUint16) (13)));
- CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, buffer, &offset, ((CsrUint16) (13)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, buffer, &offset, ((u16) (13)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, buffer, &offset, ((u16) (13)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, buffer, &offset, ((u16) (13)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, buffer, &offset, ((u16) (13)));
break;
case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey, buffer, &offset);
- CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, buffer, &offset, ((CsrUint16) (5)));
- CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, buffer, &offset, ((CsrUint16) (5)));
- CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, buffer, &offset, ((CsrUint16) (5)));
- CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, buffer, &offset, ((CsrUint16) (5)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, buffer, &offset, ((u16) (5)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, buffer, &offset, ((u16) (5)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, buffer, &offset, ((u16) (5)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, buffer, &offset, ((u16) (5)));
break;
default:
break;
break;
case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase, buffer, &offset);
switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
{
case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
- CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode, buffer, &offset);
- CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode, buffer, &offset);
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, buffer, &offset, ((u16) (32)));
break;
case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
- CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode, buffer, &offset);
CsrCharStringDes(&primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase, buffer, &offset);
break;
default:
}
CsrUint8Des((u8 *) &primitive->maxConnections, buffer, &offset);
CsrUint8Des((u8 *) &primitive->p2pGoParam.groupCapability, buffer, &offset);
- CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.country, buffer, &offset, ((CsrUint16) (3)));
+ CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.country, buffer, &offset, ((u16) (3)));
CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryListCount, buffer, &offset);
primitive->p2pGoParam.operatingChanList.channelEntryList = NULL;
if (primitive->p2pGoParam.operatingChanList.channelEntryListCount)
primitive->p2pGoParam.operatingChanList.channelEntryList = (CsrWifiSmeApP2pOperatingChanEntry *)CsrPmemAlloc(sizeof(CsrWifiSmeApP2pOperatingChanEntry) * primitive->p2pGoParam.operatingChanList.channelEntryListCount);
}
{
- CsrUint16 i3;
+ u16 i3;
for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
{
CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass, buffer, &offset);
if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
{
primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel = (u8 *)CsrPmemAlloc(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
- CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, buffer, &offset, ((CsrUint16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
+ CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, buffer, &offset, ((u16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
}
else
{
break;
}
{
- CsrUint16 i3;
+ u16 i3;
for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
{
CsrPmemFree(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 51) */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 4; i1++)
{
bufferSize += 1; /* u8 primitive->wmmApParams[i1].cwMin */
bufferSize += 1; /* u8 primitive->wmmApParams[i1].cwMax */
bufferSize += 1; /* u8 primitive->wmmApParams[i1].aifs */
- bufferSize += 2; /* CsrUint16 primitive->wmmApParams[i1].txopLimit */
+ bufferSize += 2; /* u16 primitive->wmmApParams[i1].txopLimit */
bufferSize += 1; /* CsrBool primitive->wmmApParams[i1].admissionControlMandatory */
}
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 4; i1++)
{
bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].cwMin */
bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].cwMax */
bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].aifs */
- bufferSize += 2; /* CsrUint16 primitive->wmmApBcParams[i1].txopLimit */
+ bufferSize += 2; /* u16 primitive->wmmApBcParams[i1].txopLimit */
bufferSize += 1; /* CsrBool primitive->wmmApBcParams[i1].admissionControlMandatory */
}
}
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 4; i1++)
{
CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].cwMin);
CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].cwMax);
CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].aifs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->wmmApParams[i1].txopLimit);
+ CsrUint16Ser(ptr, len, (u16) primitive->wmmApParams[i1].txopLimit);
CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].admissionControlMandatory);
}
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 4; i1++)
{
CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].cwMin);
CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].cwMax);
CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].aifs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->wmmApBcParams[i1].txopLimit);
+ CsrUint16Ser(ptr, len, (u16) primitive->wmmApBcParams[i1].txopLimit);
CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].admissionControlMandatory);
}
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 4; i1++)
{
CsrUint8Des((u8 *) &primitive->wmmApParams[i1].cwMin, buffer, &offset);
CsrUint8Des((u8 *) &primitive->wmmApParams[i1].cwMax, buffer, &offset);
CsrUint8Des((u8 *) &primitive->wmmApParams[i1].aifs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->wmmApParams[i1].txopLimit, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->wmmApParams[i1].txopLimit, buffer, &offset);
CsrUint8Des((u8 *) &primitive->wmmApParams[i1].admissionControlMandatory, buffer, &offset);
}
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 4; i1++)
{
CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].cwMin, buffer, &offset);
CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].cwMax, buffer, &offset);
CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].aifs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->wmmApBcParams[i1].txopLimit, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->wmmApBcParams[i1].txopLimit, buffer, &offset);
CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].admissionControlMandatory, buffer, &offset);
}
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 6; /* u8 primitive->staMacAddress.a[6] */
bufferSize += 1; /* CsrBool primitive->keepBlocking */
return bufferSize;
CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrMemCpySer(ptr, len, (const void *) primitive->staMacAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->staMacAddress.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->keepBlocking);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrMemCpyDes(primitive->staMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->staMacAddress.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->keepBlocking, buffer, &offset);
return primitive;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 40) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
bufferSize += 1; /* u8 primitive->ssid.length */
CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
return primitive;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeApType primitive->apType */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->apType);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->apType, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeMediaStatus primitive->mediaStatus */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 6; /* u8 primitive->peerDeviceAddress.a[6] */
CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
- CsrMemCpySer(ptr, len, (const void *) primitive->peerDeviceAddress.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerDeviceAddress.a, ((u16) (6)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrMemCpyDes(primitive->peerDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
+ CsrMemCpyDes(primitive->peerDeviceAddress.a, buffer, &offset, ((u16) (6)));
return primitive;
}
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_NME upstream message
*----------------------------------------------------------------------------*/
-void CsrWifiNmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiNmeFreeUpstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* CsrWifiNmeFreeDownstreamMessageContents
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_NME downstream message
*----------------------------------------------------------------------------*/
-void CsrWifiNmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiNmeFreeDownstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* Enum to string functions
- For future use.
*******************************************************************************/
-typedef CsrUint16 CsrWifiNmeAuthMode;
+typedef u16 CsrWifiNmeAuthMode;
#define CSR_WIFI_NME_AUTH_MODE_80211_OPEN ((CsrWifiNmeAuthMode) 0x0001)
#define CSR_WIFI_NME_AUTH_MODE_80211_SHARED ((CsrWifiNmeAuthMode) 0x0002)
#define CSR_WIFI_NME_AUTH_MODE_8021X_WPA ((CsrWifiNmeAuthMode) 0x0004)
FAST/LEAP/TLS/TTLS/PEAP/etc.
*******************************************************************************/
-typedef CsrUint16 CsrWifiNmeCredentialType;
+typedef u16 CsrWifiNmeCredentialType;
#define CSR_WIFI_NME_CREDENTIAL_TYPE_OPEN_SYSTEM ((CsrWifiNmeCredentialType) 0x0000)
#define CSR_WIFI_NME_CREDENTIAL_TYPE_WEP64 ((CsrWifiNmeCredentialType) 0x0001)
#define CSR_WIFI_NME_CREDENTIAL_TYPE_WEP128 ((CsrWifiNmeCredentialType) 0x0002)
- EAP-LEAP Method.
*******************************************************************************/
-typedef CsrUint16 CsrWifiNmeEapMethod;
+typedef u16 CsrWifiNmeEapMethod;
#define CSR_WIFI_NME_EAP_METHOD_TLS ((CsrWifiNmeEapMethod) 0x0001)
#define CSR_WIFI_NME_EAP_METHOD_TTLS_MSCHAPV2 ((CsrWifiNmeEapMethod) 0x0002)
#define CSR_WIFI_NME_EAP_METHOD_PEAP_GTC ((CsrWifiNmeEapMethod) 0x0004)
- SMS4 key for broadcast messages.
*******************************************************************************/
-typedef CsrUint16 CsrWifiNmeEncryption;
+typedef u16 CsrWifiNmeEncryption;
#define CSR_WIFI_NME_ENCRYPTION_CIPHER_NONE ((CsrWifiNmeEncryption) 0x0000)
#define CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_WEP40 ((CsrWifiNmeEncryption) 0x0001)
#define CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_WEP104 ((CsrWifiNmeEncryption) 0x0002)
Mask type for use with the values defined by CsrWifiNmeEapMethod.
*******************************************************************************/
-typedef CsrUint16 CsrWifiNmeEapMethodMask;
+typedef u16 CsrWifiNmeEapMethodMask;
/*******************************************************************************
NAME
Mask type for use with the values defined by CsrWifiNmeEncryption
*******************************************************************************/
-typedef CsrUint16 CsrWifiNmeEncryptionMask;
+typedef u16 CsrWifiNmeEncryptionMask;
/*******************************************************************************
NAME
*******************************************************************************/
typedef struct
{
- CsrUint16 encryptionMode;
+ u16 encryptionMode;
CsrCharString *passphrase;
} CsrWifiNmePassphrase;
*******************************************************************************/
typedef struct
{
- CsrUint16 encryptionMode;
+ u16 encryptionMode;
u8 psk[32];
} CsrWifiNmePsk;
{
CsrUint32 certificateLength;
u8 *certificate;
- CsrUint16 privateKeyLength;
+ u16 privateKeyLength;
u8 *privateKey;
CsrUint32 caCertificateLength;
u8 *caCertificate;
u8 *clientCertificate;
CsrUint32 certificateAuthorityCertificateLength;
u8 *certificateAuthorityCertificate;
- CsrUint16 privateKeyLength;
+ u16 privateKeyLength;
u8 *privateKey;
CsrCharString *privateKeyPassword;
CsrUint32 sessionLength;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 profileIdentitysCount;
CsrWifiNmeProfileIdentity *profileIdentitys;
} CsrWifiNmeProfileOrderSetReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiNmeProfileIdentity profileIdentity;
} CsrWifiNmeProfileConnectReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 pin[8];
CsrWifiSsid ssid;
CsrWifiMacAddress bssid;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiNmeWpsCancelReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiNmeConnectionStatusGetReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiNmeProfileOrderSetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
u8 connectAttemptsCount;
CsrWifiNmeConnectAttempt *connectAttempts;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiNmeProfile profile;
} CsrWifiNmeWpsCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiNmeWpsCancelCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiNmeConnectionStatus connectionStatus;
} CsrWifiNmeConnectionStatusGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiNmeProfile profile;
} CsrWifiNmeProfileUpdateInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 connectAttemptsCount;
CsrWifiNmeConnectAttempt *connectAttempts;
} CsrWifiNmeProfileDisconnectInd;
{ 0, NULL, NULL, NULL, NULL },
};
-CsrMsgConvMsgEntry* CsrWifiRouterConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+CsrMsgConvMsgEntry* CsrWifiRouterConverterLookup(CsrMsgConvMsgEntry *ce, u16 msgType)
{
if (msgType & CSR_PRIM_UPSTREAM)
{
- CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT;
+ u16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT;
if (idx < (CSR_WIFI_ROUTER_PRIM_UPSTREAM_COUNT + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT) &&
csrwifirouter_conv_lut[idx].msgType == msgType)
{
{ 0, NULL, NULL, NULL, NULL },
};
-CsrMsgConvMsgEntry* CsrWifiRouterCtrlConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+CsrMsgConvMsgEntry* CsrWifiRouterCtrlConverterLookup(CsrMsgConvMsgEntry *ce, u16 msgType)
{
if (msgType & CSR_PRIM_UPSTREAM)
{
- CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT;
+ u16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT;
if (idx < (CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_COUNT + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT) &&
csrwifirouterctrl_conv_lut[idx].msgType == msgType)
{
* eventClass: only the value CSR_WIFI_ROUTER_CTRL_PRIM will be handled
* message: the message to free
*----------------------------------------------------------------------------*/
-void CsrWifiRouterCtrlFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiRouterCtrlFreeDownstreamMessageContents(u16 eventClass, void *message)
{
if (eventClass != CSR_WIFI_ROUTER_CTRL_PRIM)
{
* eventClass: only the value CSR_WIFI_ROUTER_CTRL_PRIM will be handled
* message: the message to free
*----------------------------------------------------------------------------*/
-void CsrWifiRouterCtrlFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiRouterCtrlFreeUpstreamMessageContents(u16 eventClass, void *message)
{
if (eventClass != CSR_WIFI_ROUTER_CTRL_PRIM)
{
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_ROUTER_CTRL upstream message
*----------------------------------------------------------------------------*/
-void CsrWifiRouterCtrlFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiRouterCtrlFreeUpstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* CsrWifiRouterCtrlFreeDownstreamMessageContents
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_ROUTER_CTRL downstream message
*----------------------------------------------------------------------------*/
-void CsrWifiRouterCtrlFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiRouterCtrlFreeDownstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* Enum to string functions
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, CsrUint16 *pdata);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(u8 func, CsrUint32 address, CsrUint16 data);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpRead16)(u8 func, CsrUint32 address, u16 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(u8 func, CsrUint32 address, u16 data);
/*******************************************************************************
-
*******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlLowPowerMode;
+typedef u16 CsrWifiRouterCtrlLowPowerMode;
#define CSR_WIFI_ROUTER_CTRL_LOW_POWER_MODE_DISABLED ((CsrWifiRouterCtrlLowPowerMode) 0x0000)
#define CSR_WIFI_ROUTER_CTRL_LOW_POWER_MODE_ENABLED ((CsrWifiRouterCtrlLowPowerMode) 0x0001)
-
*******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlPortAction;
+typedef u16 CsrWifiRouterCtrlPortAction;
#define CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN ((CsrWifiRouterCtrlPortAction) 0x0000)
#define CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD ((CsrWifiRouterCtrlPortAction) 0x0001)
#define CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_BLOCK ((CsrWifiRouterCtrlPortAction) 0x0002)
-
*******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlPowersaveType;
+typedef u16 CsrWifiRouterCtrlPowersaveType;
#define CSR_WIFI_ROUTER_CTRL_AC_BK_PS_INFO_PRESENT ((CsrWifiRouterCtrlPowersaveType) 0x0001)
#define CSR_WIFI_ROUTER_CTRL_AC_BE_PS_INFO_PRESENT ((CsrWifiRouterCtrlPowersaveType) 0x0002)
#define CSR_WIFI_ROUTER_CTRL_AC_VI_PS_INFO_PRESENT ((CsrWifiRouterCtrlPowersaveType) 0x0004)
-
*******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlProtocolDirection;
+typedef u16 CsrWifiRouterCtrlProtocolDirection;
#define CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_RX ((CsrWifiRouterCtrlProtocolDirection) 0x0000)
#define CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX ((CsrWifiRouterCtrlProtocolDirection) 0x0001)
-
*******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlQoSControl;
+typedef u16 CsrWifiRouterCtrlQoSControl;
#define CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_OFF ((CsrWifiRouterCtrlQoSControl) 0x0000)
#define CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_WMM_ON ((CsrWifiRouterCtrlQoSControl) 0x0001)
#define CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_80211_ON ((CsrWifiRouterCtrlQoSControl) 0x0002)
-
*******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlTrafficConfigType;
+typedef u16 CsrWifiRouterCtrlTrafficConfigType;
#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_RESET ((CsrWifiRouterCtrlTrafficConfigType) 0x0000)
#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_FILTER ((CsrWifiRouterCtrlTrafficConfigType) 0x0001)
#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_CLS ((CsrWifiRouterCtrlTrafficConfigType) 0x0002)
-
*******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlTrafficPacketType;
+typedef u16 CsrWifiRouterCtrlTrafficPacketType;
#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_NONE ((CsrWifiRouterCtrlTrafficPacketType) 0x0000)
#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_EAPOL ((CsrWifiRouterCtrlTrafficPacketType) 0x0001)
#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP ((CsrWifiRouterCtrlTrafficPacketType) 0x0002)
CsrWifiRouterCtrlPowersaveType
*******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlPowersaveTypeMask;
+typedef u16 CsrWifiRouterCtrlPowersaveTypeMask;
/*******************************************************************************
NAME
DESCRIPTION
*******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlRequestorInfo;
+typedef u16 CsrWifiRouterCtrlRequestorInfo;
/*******************************************************************************
NAME
CsrBool wmmOrQosEnabled;
CsrWifiRouterCtrlPowersaveTypeMask powersaveMode;
u8 maxSpLength;
- CsrUint16 listenIntervalInTus;
+ u16 listenIntervalInTus;
} CsrWifiRouterCtrlStaInfo;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint16 packetFilter;
+ u16 packetFilter;
CsrWifiRouterCtrlTrafficFilter customFilter;
} CsrWifiRouterCtrlTrafficConfig;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 mlmeCommandLength;
+ u16 mlmeCommandLength;
u8 *mlmeCommand;
- CsrUint16 dataRef1Length;
+ u16 dataRef1Length;
u8 *dataRef1;
- CsrUint16 dataRef2Length;
+ u16 dataRef2Length;
u8 *dataRef2;
} CsrWifiRouterCtrlHipReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiRouterCtrlMediaStatus mediaStatus;
} CsrWifiRouterCtrlMediaStatusReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrResult status;
CsrWifiRouterCtrlListAction action;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiRouterCtrlPortAction uncontrolledPortAction;
CsrWifiRouterCtrlPortAction controlledPortAction;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiRouterCtrlQoSControl control;
CsrWifiRouterCtrlQueueConfigMask queueConfig;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 tclasLength;
+ u16 tclasLength;
u8 *tclas;
} CsrWifiRouterCtrlTclasAddReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 tclasLength;
+ u16 tclasLength;
u8 *tclas;
} CsrWifiRouterCtrlTclasDelReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiRouterCtrlTrafficType trafficType;
- CsrUint16 period;
+ u16 period;
} CsrWifiRouterCtrlTrafficClassificationReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiRouterCtrlTrafficConfigType trafficConfigType;
CsrWifiRouterCtrlTrafficConfig config;
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrResult status;
- CsrUint16 numInterfaceAddress;
+ u16 numInterfaceAddress;
CsrWifiMacAddress stationMacAddress[2];
CsrWifiRouterCtrlSmeVersions smeVersions;
CsrBool scheduledInterrupt;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
} CsrWifiRouterCtrlM4TransmitReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiRouterCtrlMode mode;
CsrWifiMacAddress bssid;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiMacAddress peerMacAddress;
- CsrUint16 associationId;
+ u16 associationId;
CsrWifiRouterCtrlStaInfo staInfo;
} CsrWifiRouterCtrlPeerAddReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiRouterCtrlPeerRecordHandle peerRecordHandle;
} CsrWifiRouterCtrlPeerDelReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiRouterCtrlPeerRecordHandle peerRecordHandle;
CsrWifiRouterCtrlPowersaveTypeMask powersaveMode;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiMacAddress macAddress;
CsrWifiRouterCtrlTrafficStreamId trafficStreamID;
CsrWifiRouterCtrlBlockAckRole role;
- CsrUint16 bufferSize;
- CsrUint16 timeout;
- CsrUint16 ssn;
+ u16 bufferSize;
+ u16 timeout;
+ u16 ssn;
} CsrWifiRouterCtrlBlockAckEnableReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrWifiMacAddress macAddress;
CsrWifiRouterCtrlTrafficStreamId trafficStreamID;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
- CsrUint16 signalLength;
+ u16 interfaceTag;
+ u16 signalLength;
u8 *signal;
- CsrUint16 dataLength;
+ u16 dataLength;
u8 *data;
} CsrWifiRouterCtrlWapiRxPktReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 status;
} CsrWifiRouterCtrlWapiMulticastFilterReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 status;
} CsrWifiRouterCtrlWapiUnicastFilterReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
- CsrUint16 dataLength;
+ u16 interfaceTag;
+ u16 dataLength;
u8 *data;
} CsrWifiRouterCtrlWapiUnicastTxPktReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrBool isWapiConnected;
} CsrWifiRouterCtrlWapiFilterReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 mlmeCommandLength;
+ u16 mlmeCommandLength;
u8 *mlmeCommand;
- CsrUint16 dataRef1Length;
+ u16 dataRef1Length;
u8 *dataRef1;
- CsrUint16 dataRef2Length;
+ u16 dataRef2Length;
u8 *dataRef2;
} CsrWifiRouterCtrlHipInd;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlListAction action;
u8 setAddressesCount;
CsrWifiMacAddress *setAddresses;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiMacAddress macAddress;
} CsrWifiRouterCtrlPortConfigureCfm;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiRouterCtrlTclasAddCfm;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiRouterCtrlTclasDelCfm;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlTrafficPacketType packetType;
CsrWifiRouterCtrlProtocolDirection direction;
CsrWifiMacAddress srcAddress;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlTrafficStats stats;
} CsrWifiRouterCtrlTrafficSampleInd;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress peerMacAddress;
} CsrWifiRouterCtrlM4ReadyToSendInd;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress peerMacAddress;
CsrResult status;
} CsrWifiRouterCtrlM4TransmittedInd;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress peerMacAddress;
CsrBool unicastPdu;
} CsrWifiRouterCtrlMicFailureInd;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress peerMacAddress;
CsrWifiRouterCtrlPeerStatus peerStatus;
} CsrWifiRouterCtrlConnectedInd;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress peerMacAddress;
CsrWifiRouterCtrlPeerRecordHandle peerRecordHandle;
CsrResult status;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiRouterCtrlPeerDelCfm;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress peerMacAddress;
} CsrWifiRouterCtrlUnexpectedFrameInd;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiRouterCtrlPeerUpdateCfm;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 commandQueueSize;
- CsrUint16 trafficQueueSize;
+ u16 commandQueueSize;
+ u16 trafficQueueSize;
} CsrWifiRouterCtrlCapabilitiesCfm;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiRouterCtrlBlockAckEnableCfm;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiRouterCtrlBlockAckDisableCfm;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlTrafficStreamId trafficStreamID;
CsrWifiMacAddress peerMacAddress;
CsrResult status;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress staAddress;
} CsrWifiRouterCtrlStaInactiveInd;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
- CsrUint16 signalLength;
+ u16 interfaceTag;
+ u16 signalLength;
u8 *signal;
- CsrUint16 dataLength;
+ u16 dataLength;
u8 *data;
} CsrWifiRouterCtrlWapiRxMicCheckInd;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterCtrlMode mode;
CsrResult status;
} CsrWifiRouterCtrlModeSetCfm;
{
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
- CsrUint16 interfaceTag;
- CsrUint16 dataLength;
+ u16 interfaceTag;
+ u16 dataLength;
u8 *data;
} CsrWifiRouterCtrlWapiUnicastTxEncryptInd;
CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mode);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->mode);
CsrUint8Ser(ptr, len, (u8) primitive->wakeHost);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mode, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mode, buffer, &offset);
CsrUint8Des((u8 *) &primitive->wakeHost, buffer, &offset);
return primitive;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
- bufferSize += 2; /* CsrUint16 primitive->mlmeCommandLength */
+ bufferSize += 2; /* u16 primitive->mlmeCommandLength */
bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
- bufferSize += 2; /* CsrUint16 primitive->dataRef1Length */
+ bufferSize += 2; /* u16 primitive->dataRef1Length */
bufferSize += primitive->dataRef1Length; /* u8 primitive->dataRef1 */
- bufferSize += 2; /* CsrUint16 primitive->dataRef2Length */
+ bufferSize += 2; /* u16 primitive->dataRef2Length */
bufferSize += primitive->dataRef2Length; /* u8 primitive->dataRef2 */
return bufferSize;
}
CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mlmeCommandLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->mlmeCommandLength);
if (primitive->mlmeCommandLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((CsrUint16) (primitive->mlmeCommandLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((u16) (primitive->mlmeCommandLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef1Length);
+ CsrUint16Ser(ptr, len, (u16) primitive->dataRef1Length);
if (primitive->dataRef1Length)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((CsrUint16) (primitive->dataRef1Length)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((u16) (primitive->dataRef1Length)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef2Length);
+ CsrUint16Ser(ptr, len, (u16) primitive->dataRef2Length);
if (primitive->dataRef2Length)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((CsrUint16) (primitive->dataRef2Length)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((u16) (primitive->dataRef2Length)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mlmeCommandLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mlmeCommandLength, buffer, &offset);
if (primitive->mlmeCommandLength)
{
primitive->mlmeCommand = (u8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
- CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((CsrUint16) (primitive->mlmeCommandLength)));
+ CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((u16) (primitive->mlmeCommandLength)));
}
else
{
primitive->mlmeCommand = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->dataRef1Length, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->dataRef1Length, buffer, &offset);
if (primitive->dataRef1Length)
{
primitive->dataRef1 = (u8 *)CsrPmemAlloc(primitive->dataRef1Length);
- CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((CsrUint16) (primitive->dataRef1Length)));
+ CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((u16) (primitive->dataRef1Length)));
}
else
{
primitive->dataRef1 = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->dataRef2Length, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->dataRef2Length, buffer, &offset);
if (primitive->dataRef2Length)
{
primitive->dataRef2 = (u8 *)CsrPmemAlloc(primitive->dataRef2Length);
- CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((CsrUint16) (primitive->dataRef2Length)));
+ CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((u16) (primitive->dataRef2Length)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 1; /* CsrWifiRouterCtrlMediaStatus primitive->mediaStatus */
return bufferSize;
CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
return primitive;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
bufferSize += 1; /* u8 primitive->getAddressesCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
{
bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint8Ser(ptr, len, (u8) primitive->getAddressesCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((u16) (6)));
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint8Des((u8 *) &primitive->getAddressesCount, buffer, &offset);
primitive->getAddresses = NULL;
primitive->getAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->getAddressesCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
{
- CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((u16) (6)));
}
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->uncontrolledPortAction */
bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->controlledPortAction */
CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->uncontrolledPortAction);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->controlledPortAction);
- CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->uncontrolledPortAction);
+ CsrUint16Ser(ptr, len, (u16) primitive->controlledPortAction);
+ CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->setProtection);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->uncontrolledPortAction, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->controlledPortAction, buffer, &offset);
- CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->uncontrolledPortAction, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->controlledPortAction, buffer, &offset);
+ CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->setProtection, buffer, &offset);
return primitive;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrWifiRouterCtrlQoSControl primitive->control */
bufferSize += 1; /* CsrWifiRouterCtrlQueueConfigMask primitive->queueConfig */
CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->control);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->control);
CsrUint8Ser(ptr, len, (u8) primitive->queueConfig);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->control, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->control, buffer, &offset);
CsrUint8Des((u8 *) &primitive->queueConfig, buffer, &offset);
return primitive;
CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->tclasLength */
+ bufferSize += 2; /* u16 primitive->tclasLength */
bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
return bufferSize;
}
CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->tclasLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->tclasLength);
if (primitive->tclasLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((CsrUint16) (primitive->tclasLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((u16) (primitive->tclasLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->tclasLength, buffer, &offset);
if (primitive->tclasLength)
{
primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
- CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
+ CsrMemCpyDes(primitive->tclas, buffer, &offset, ((u16) (primitive->tclasLength)));
}
else
{
CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->tclasLength */
+ bufferSize += 2; /* u16 primitive->tclasLength */
bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
return bufferSize;
}
CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->tclasLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->tclasLength);
if (primitive->tclasLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((CsrUint16) (primitive->tclasLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((u16) (primitive->tclasLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->tclasLength, buffer, &offset);
if (primitive->tclasLength)
{
primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
- CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
+ CsrMemCpyDes(primitive->tclas, buffer, &offset, ((u16) (primitive->tclasLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 1; /* CsrWifiRouterCtrlTrafficType primitive->trafficType */
- bufferSize += 2; /* CsrUint16 primitive->period */
+ bufferSize += 2; /* u16 primitive->period */
return bufferSize;
}
CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint8Ser(ptr, len, (u8) primitive->trafficType);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->period);
+ CsrUint16Ser(ptr, len, (u16) primitive->period);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint8Des((u8 *) &primitive->trafficType, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->period, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->period, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 24) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrWifiRouterCtrlTrafficConfigType primitive->trafficConfigType */
- bufferSize += 2; /* CsrUint16 primitive->config.packetFilter */
+ bufferSize += 2; /* u16 primitive->config.packetFilter */
bufferSize += 4; /* CsrUint32 primitive->config.customFilter.etherType */
bufferSize += 1; /* u8 primitive->config.customFilter.ipType */
bufferSize += 4; /* CsrUint32 primitive->config.customFilter.udpSourcePort */
CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->trafficConfigType);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->config.packetFilter);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ 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);
CsrUint8Ser(ptr, len, (u8) primitive->config.customFilter.ipType);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.udpSourcePort);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->trafficConfigType, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->config.packetFilter, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ 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);
CsrUint8Des((u8 *) &primitive->config.customFilter.ipType, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.udpSourcePort, buffer, &offset);
CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
if (primitive->dataLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
- CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
}
else
{
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 30) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 2; /* CsrUint16 primitive->numInterfaceAddress */
+ bufferSize += 2; /* u16 primitive->numInterfaceAddress */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 2; i1++)
{
bufferSize += 6; /* u8 primitive->stationMacAddress[i1].a[6] */
CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->numInterfaceAddress);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->numInterfaceAddress);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 2; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((u16) (6)));
}
}
CsrUint32Ser(ptr, len, (CsrUint32) primitive->smeVersions.firmwarePatch);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->numInterfaceAddress, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->numInterfaceAddress, buffer, &offset);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 2; i1++)
{
- CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((u16) (6)));
}
}
CsrUint32Des((CsrUint32 *) &primitive->smeVersions.firmwarePatch, buffer, &offset);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
return bufferSize;
}
CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
bufferSize += 6; /* u8 primitive->bssid.a[6] */
CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint8Ser(ptr, len, (u8) primitive->mode);
- CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->protection);
CsrUint8Ser(ptr, len, (u8) primitive->intraBssDistEnabled);
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
- CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->protection, buffer, &offset);
CsrUint8Des((u8 *) &primitive->intraBssDistEnabled, buffer, &offset);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
- bufferSize += 2; /* CsrUint16 primitive->associationId */
+ bufferSize += 2; /* u16 primitive->associationId */
bufferSize += 1; /* CsrBool primitive->staInfo.wmmOrQosEnabled */
bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->staInfo.powersaveMode */
bufferSize += 1; /* u8 primitive->staInfo.maxSpLength */
- bufferSize += 2; /* CsrUint16 primitive->staInfo.listenIntervalInTus */
+ bufferSize += 2; /* u16 primitive->staInfo.listenIntervalInTus */
return bufferSize;
}
CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->associationId);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->associationId);
CsrUint8Ser(ptr, len, (u8) primitive->staInfo.wmmOrQosEnabled);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->staInfo.powersaveMode);
+ CsrUint16Ser(ptr, len, (u16) primitive->staInfo.powersaveMode);
CsrUint8Ser(ptr, len, (u8) primitive->staInfo.maxSpLength);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->staInfo.listenIntervalInTus);
+ CsrUint16Ser(ptr, len, (u16) primitive->staInfo.listenIntervalInTus);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->associationId, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->associationId, buffer, &offset);
CsrUint8Des((u8 *) &primitive->staInfo.wmmOrQosEnabled, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->staInfo.powersaveMode, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->staInfo.powersaveMode, buffer, &offset);
CsrUint8Des((u8 *) &primitive->staInfo.maxSpLength, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->staInfo.listenIntervalInTus, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->staInfo.listenIntervalInTus, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
return bufferSize;
CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
return primitive;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->powersaveMode */
CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->powersaveMode);
+ CsrUint16Ser(ptr, len, (u16) primitive->powersaveMode);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->powersaveMode, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->powersaveMode, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 6; /* u8 primitive->macAddress.a[6] */
bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
- bufferSize += 2; /* CsrUint16 primitive->bufferSize */
- bufferSize += 2; /* CsrUint16 primitive->timeout */
- bufferSize += 2; /* CsrUint16 primitive->ssn */
+ bufferSize += 2; /* u16 primitive->bufferSize */
+ bufferSize += 2; /* u16 primitive->timeout */
+ bufferSize += 2; /* u16 primitive->ssn */
return bufferSize;
}
CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
CsrUint8Ser(ptr, len, (u8) primitive->role);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->bufferSize);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->timeout);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->ssn);
+ CsrUint16Ser(ptr, len, (u16) primitive->bufferSize);
+ CsrUint16Ser(ptr, len, (u16) primitive->timeout);
+ CsrUint16Ser(ptr, len, (u16) primitive->ssn);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->bufferSize, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->timeout, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->ssn, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->bufferSize, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->timeout, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->ssn, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 6; /* u8 primitive->macAddress.a[6] */
bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
CsrUint8Ser(ptr, len, (u8) primitive->role);
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 2; /* CsrUint16 primitive->signalLength */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->signalLength */
bufferSize += primitive->signalLength; /* u8 primitive->signal */
- bufferSize += 2; /* CsrUint16 primitive->dataLength */
+ bufferSize += 2; /* u16 primitive->dataLength */
bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->signalLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->signalLength);
if (primitive->signalLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((CsrUint16) (primitive->signalLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((u16) (primitive->signalLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
if (primitive->dataLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->signalLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->signalLength, buffer, &offset);
if (primitive->signalLength)
{
primitive->signal = (u8 *)CsrPmemAlloc(primitive->signalLength);
- CsrMemCpyDes(primitive->signal, buffer, &offset, ((CsrUint16) (primitive->signalLength)));
+ CsrMemCpyDes(primitive->signal, buffer, &offset, ((u16) (primitive->signalLength)));
}
else
{
primitive->signal = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
- CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 2; /* CsrUint16 primitive->dataLength */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->dataLength */
bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
if (primitive->dataLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
- CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
- bufferSize += 2; /* CsrUint16 primitive->mlmeCommandLength */
+ bufferSize += 2; /* u16 primitive->mlmeCommandLength */
bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
- bufferSize += 2; /* CsrUint16 primitive->dataRef1Length */
+ bufferSize += 2; /* u16 primitive->dataRef1Length */
bufferSize += primitive->dataRef1Length; /* u8 primitive->dataRef1 */
- bufferSize += 2; /* CsrUint16 primitive->dataRef2Length */
+ bufferSize += 2; /* u16 primitive->dataRef2Length */
bufferSize += primitive->dataRef2Length; /* u8 primitive->dataRef2 */
return bufferSize;
}
CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mlmeCommandLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->mlmeCommandLength);
if (primitive->mlmeCommandLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((CsrUint16) (primitive->mlmeCommandLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((u16) (primitive->mlmeCommandLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef1Length);
+ CsrUint16Ser(ptr, len, (u16) primitive->dataRef1Length);
if (primitive->dataRef1Length)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((CsrUint16) (primitive->dataRef1Length)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((u16) (primitive->dataRef1Length)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef2Length);
+ CsrUint16Ser(ptr, len, (u16) primitive->dataRef2Length);
if (primitive->dataRef2Length)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((CsrUint16) (primitive->dataRef2Length)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((u16) (primitive->dataRef2Length)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mlmeCommandLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mlmeCommandLength, buffer, &offset);
if (primitive->mlmeCommandLength)
{
primitive->mlmeCommand = (u8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
- CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((CsrUint16) (primitive->mlmeCommandLength)));
+ CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((u16) (primitive->mlmeCommandLength)));
}
else
{
primitive->mlmeCommand = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->dataRef1Length, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->dataRef1Length, buffer, &offset);
if (primitive->dataRef1Length)
{
primitive->dataRef1 = (u8 *)CsrPmemAlloc(primitive->dataRef1Length);
- CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((CsrUint16) (primitive->dataRef1Length)));
+ CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((u16) (primitive->dataRef1Length)));
}
else
{
primitive->dataRef1 = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->dataRef2Length, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->dataRef2Length, buffer, &offset);
if (primitive->dataRef2Length)
{
primitive->dataRef2 = (u8 *)CsrPmemAlloc(primitive->dataRef2Length);
- CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((CsrUint16) (primitive->dataRef2Length)));
+ CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((u16) (primitive->dataRef2Length)));
}
else
{
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
bufferSize += 1; /* u8 primitive->setAddressesCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
{
bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint8Ser(ptr, len, (u8) primitive->setAddressesCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((u16) (6)));
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint8Des((u8 *) &primitive->setAddressesCount, buffer, &offset);
primitive->setAddresses = NULL;
primitive->setAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->setAddressesCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
{
- CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((u16) (6)));
}
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 6; /* u8 primitive->macAddress.a[6] */
return bufferSize;
CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
return primitive;
}
CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
CsrUint8Ser(ptr, len, (u8) primitive->hardSuspend);
CsrUint8Ser(ptr, len, (u8) primitive->d3Suspend);
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
CsrUint8Des((u8 *) &primitive->hardSuspend, buffer, &offset);
CsrUint8Des((u8 *) &primitive->d3Suspend, buffer, &offset);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->result);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
return primitive;
}
CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->result);
CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteRead */
CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteWrite */
CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->firmwareDownload */
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
primitive->byteRead = NULL; /* Special for Function Pointers... */
offset += 4;
primitive->byteWrite = NULL; /* Special for Function Pointers... */
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlTrafficPacketType primitive->packetType */
bufferSize += 2; /* CsrWifiRouterCtrlProtocolDirection primitive->direction */
bufferSize += 6; /* u8 primitive->srcAddress.a[6] */
CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->packetType);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->direction);
- CsrMemCpySer(ptr, len, (const void *) primitive->srcAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->packetType);
+ CsrUint16Ser(ptr, len, (u16) primitive->direction);
+ CsrMemCpySer(ptr, len, (const void *) primitive->srcAddress.a, ((u16) (6)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->packetType, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->direction, buffer, &offset);
- CsrMemCpyDes(primitive->srcAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->packetType, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->direction, buffer, &offset);
+ CsrMemCpyDes(primitive->srcAddress.a, buffer, &offset, ((u16) (6)));
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 38) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 4; /* CsrUint32 primitive->stats.rxMeanRate */
bufferSize += 4; /* CsrUint32 primitive->stats.rxFramesNum */
bufferSize += 4; /* CsrUint32 primitive->stats.txFramesNum */
CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ 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);
- CsrMemCpySer(ptr, len, (const void *) primitive->stats.intervals, ((CsrUint16) (11)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->stats.intervals, ((u16) (11)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, 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);
- CsrMemCpyDes(primitive->stats.intervals, buffer, &offset, ((CsrUint16) (11)));
+ CsrMemCpyDes(primitive->stats.intervals, buffer, &offset, ((u16) (11)));
return primitive;
}
CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ 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);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, 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);
CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
return bufferSize;
}
CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 1; /* CsrBool primitive->unicastPdu */
return bufferSize;
CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->unicastPdu);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->unicastPdu, buffer, &offset);
return primitive;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 1; /* CsrWifiRouterCtrlPeerStatus primitive->peerStatus */
return bufferSize;
CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->peerStatus);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->peerStatus, buffer, &offset);
return primitive;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 19) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
bufferSize += 2; /* CsrResult primitive->status */
CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ 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);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ 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);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
return bufferSize;
}
CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->commandQueueSize */
- bufferSize += 2; /* CsrUint16 primitive->trafficQueueSize */
+ bufferSize += 2; /* u16 primitive->commandQueueSize */
+ bufferSize += 2; /* u16 primitive->trafficQueueSize */
return bufferSize;
}
CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->commandQueueSize);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->trafficQueueSize);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->commandQueueSize);
+ CsrUint16Ser(ptr, len, (u16) primitive->trafficQueueSize);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->commandQueueSize, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->trafficQueueSize, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->commandQueueSize, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->trafficQueueSize, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 2; /* CsrResult primitive->status */
CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 6; /* u8 primitive->staAddress.a[6] */
return bufferSize;
}
CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrMemCpySer(ptr, len, (const void *) primitive->staAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->staAddress.a, ((u16) (6)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrMemCpyDes(primitive->staAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->staAddress.a, buffer, &offset, ((u16) (6)));
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 2; /* CsrUint16 primitive->signalLength */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->signalLength */
bufferSize += primitive->signalLength; /* u8 primitive->signal */
- bufferSize += 2; /* CsrUint16 primitive->dataLength */
+ bufferSize += 2; /* u16 primitive->dataLength */
bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->signalLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->signalLength);
if (primitive->signalLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((CsrUint16) (primitive->signalLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((u16) (primitive->signalLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
if (primitive->dataLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->signalLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->signalLength, buffer, &offset);
if (primitive->signalLength)
{
primitive->signal = (u8 *)CsrPmemAlloc(primitive->signalLength);
- CsrMemCpyDes(primitive->signal, buffer, &offset, ((CsrUint16) (primitive->signalLength)));
+ CsrMemCpyDes(primitive->signal, buffer, &offset, ((u16) (primitive->signalLength)));
}
else
{
primitive->signal = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
- CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
}
else
{
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->mode);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 2; /* CsrUint16 primitive->dataLength */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->dataLength */
bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
if (primitive->dataLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
- CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
}
else
{
* eventClass: only the value CSR_WIFI_ROUTER_PRIM will be handled
* message: the message to free
*----------------------------------------------------------------------------*/
-void CsrWifiRouterFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiRouterFreeDownstreamMessageContents(u16 eventClass, void *message)
{
if (eventClass != CSR_WIFI_ROUTER_PRIM)
{
* eventClass: only the value CSR_WIFI_ROUTER_PRIM will be handled
* message: the message to free
*----------------------------------------------------------------------------*/
-void CsrWifiRouterFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiRouterFreeUpstreamMessageContents(u16 eventClass, void *message)
{
if (eventClass != CSR_WIFI_ROUTER_PRIM)
{
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_ROUTER upstream message
*----------------------------------------------------------------------------*/
-void CsrWifiRouterFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiRouterFreeUpstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* CsrWifiRouterFreeDownstreamMessageContents
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_ROUTER downstream message
*----------------------------------------------------------------------------*/
-void CsrWifiRouterFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiRouterFreeDownstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* Enum to string functions
- See IEEE 802.11 Standard
*******************************************************************************/
-typedef CsrUint16 CsrWifiRouterPriority;
+typedef u16 CsrWifiRouterPriority;
#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP0 ((CsrWifiRouterPriority) 0x0000)
#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP1 ((CsrWifiRouterPriority) 0x0001)
#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP2 ((CsrWifiRouterPriority) 0x0002)
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiRouterEncapsulation encapsulation;
- CsrUint16 protocol;
+ u16 protocol;
CsrUint32 oui;
} CsrWifiRouterMaPacketSubscribeReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 subscriptionHandle;
} CsrWifiRouterMaPacketUnsubscribeReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 subscriptionHandle;
- CsrUint16 frameLength;
+ u16 frameLength;
u8 *frame;
CsrWifiRouterFrameFreeFunction freeFunction;
CsrWifiRouterPriority priority;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 subscriptionHandle;
CsrResult result;
} CsrWifiRouterMaPacketRes;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrUint32 hostTag;
CsrWifiRouterPriority priority;
CsrWifiMacAddress peerMacAddress;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 subscriptionHandle;
CsrResult status;
- CsrUint16 allocOffset;
+ u16 allocOffset;
} CsrWifiRouterMaPacketSubscribeCfm;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiRouterMaPacketUnsubscribeCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult result;
CsrUint32 hostTag;
- CsrUint16 rate;
+ u16 rate;
} CsrWifiRouterMaPacketCfm;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 subscriptionHandle;
CsrResult result;
- CsrUint16 frameLength;
+ u16 frameLength;
u8 *frame;
CsrWifiRouterFrameFreeFunction freeFunction;
CsrInt16 rssi;
CsrInt16 snr;
- CsrUint16 rate;
+ u16 rate;
} CsrWifiRouterMaPacketInd;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiRouterEncapsulation primitive->encapsulation */
- bufferSize += 2; /* CsrUint16 primitive->protocol */
+ bufferSize += 2; /* u16 primitive->protocol */
bufferSize += 4; /* CsrUint32 primitive->oui */
return bufferSize;
}
CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->encapsulation);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->protocol);
+ CsrUint16Ser(ptr, len, (u16) primitive->protocol);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->oui);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->encapsulation, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->protocol, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->protocol, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->oui, buffer, &offset);
return primitive;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 20) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* u8 primitive->subscriptionHandle */
- bufferSize += 2; /* CsrUint16 primitive->frameLength */
+ bufferSize += 2; /* u16 primitive->frameLength */
bufferSize += primitive->frameLength; /* u8 primitive->frame */
bufferSize += 4; /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->frameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->frameLength);
if (primitive->frameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((CsrUint16) (primitive->frameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((u16) (primitive->frameLength)));
}
CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->priority);
+ CsrUint16Ser(ptr, len, (u16) primitive->priority);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
CsrUint8Ser(ptr, len, (u8) primitive->cfmRequested);
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->frameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->frameLength, buffer, &offset);
if (primitive->frameLength)
{
primitive->frame = (u8 *)CsrPmemAlloc(primitive->frameLength);
- CsrMemCpyDes(primitive->frame, buffer, &offset, ((CsrUint16) (primitive->frameLength)));
+ CsrMemCpyDes(primitive->frame, buffer, &offset, ((u16) (primitive->frameLength)));
}
else
{
}
primitive->freeFunction = NULL; /* Special for Function Pointers... */
offset += 4;
- CsrUint16Des((CsrUint16 *) &primitive->priority, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->priority, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->cfmRequested, buffer, &offset);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* u8 primitive->subscriptionHandle */
bufferSize += 2; /* CsrResult primitive->result */
return bufferSize;
CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+ CsrUint16Ser(ptr, len, (u16) primitive->result);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 4; /* CsrUint32 primitive->hostTag */
bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->priority);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->priority);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->priority, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->priority, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* u8 primitive->subscriptionHandle */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 2; /* CsrUint16 primitive->allocOffset */
+ bufferSize += 2; /* u16 primitive->allocOffset */
return bufferSize;
}
CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->allocOffset);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->allocOffset);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->allocOffset, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->allocOffset, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->result */
bufferSize += 4; /* CsrUint32 primitive->hostTag */
- bufferSize += 2; /* CsrUint16 primitive->rate */
+ bufferSize += 2; /* u16 primitive->rate */
return bufferSize;
}
CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->result);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->rate);
+ CsrUint16Ser(ptr, len, (u16) primitive->rate);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->rate, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->rate, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* u8 primitive->subscriptionHandle */
bufferSize += 2; /* CsrResult primitive->result */
- bufferSize += 2; /* CsrUint16 primitive->frameLength */
+ bufferSize += 2; /* u16 primitive->frameLength */
bufferSize += primitive->frameLength; /* u8 primitive->frame */
bufferSize += 4; /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
bufferSize += 2; /* CsrInt16 primitive->rssi */
bufferSize += 2; /* CsrInt16 primitive->snr */
- bufferSize += 2; /* CsrUint16 primitive->rate */
+ bufferSize += 2; /* u16 primitive->rate */
return bufferSize;
}
CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->frameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->result);
+ CsrUint16Ser(ptr, len, (u16) primitive->frameLength);
if (primitive->frameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((CsrUint16) (primitive->frameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((u16) (primitive->frameLength)));
}
CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->rssi);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->snr);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->rate);
+ CsrUint16Ser(ptr, len, (u16) primitive->rssi);
+ CsrUint16Ser(ptr, len, (u16) primitive->snr);
+ CsrUint16Ser(ptr, len, (u16) primitive->rate);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->frameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->frameLength, buffer, &offset);
if (primitive->frameLength)
{
primitive->frame = (u8 *)CsrPmemAlloc(primitive->frameLength);
- CsrMemCpyDes(primitive->frame, buffer, &offset, ((CsrUint16) (primitive->frameLength)));
+ CsrMemCpyDes(primitive->frame, buffer, &offset, ((u16) (primitive->frameLength)));
}
else
{
}
primitive->freeFunction = NULL; /* Special for Function Pointers... */
offset += 4;
- CsrUint16Des((CsrUint16 *) &primitive->rssi, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->snr, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->rate, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->rssi, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->snr, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->rate, buffer, &offset);
return primitive;
}
void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLength)
{
CsrMsgConvMsgEntry* msgEntry;
- CsrUint16 primType;
+ u16 primType;
CsrSchedQid src;
CsrSchedQid dest;
- CsrUint16 msgType;
+ u16 msgType;
CsrSize offset = 0;
CsrWifiFsmEvent* msg;
if (req.dataRef1Length)
{
- CsrUint16 dr1Offset = (bufferLength - req.dataRef2Length) - req.dataRef1Length;
+ u16 dr1Offset = (bufferLength - req.dataRef2Length) - req.dataRef1Length;
req.dataRef1 = &buffer[dr1Offset];
}
if (req.dataRef2Length)
{
- CsrUint16 dr2Offset = bufferLength - req.dataRef2Length;
+ u16 dr2Offset = bufferLength - req.dataRef2Length;
req.dataRef2 = &buffer[dr2Offset];
}
CsrPmemFree(msg);
}
-static void CsrWifiRouterTransportSerialiseAndSend(CsrUint16 primType, void* msg)
+static void CsrWifiRouterTransportSerialiseAndSend(u16 primType, void* msg)
{
CsrWifiFsmEvent* evt = (CsrWifiFsmEvent*)msg;
CsrMsgConvMsgEntry* msgEntry;
}
#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
-void CsrSchedMessagePutStringLog(CsrSchedQid q, CsrUint16 mi, void *mv, CsrUint32 line, CsrCharString *file)
+void CsrSchedMessagePutStringLog(CsrSchedQid q, u16 mi, void *mv, CsrUint32 line, CsrCharString *file)
#else
-void CsrSchedMessagePut(CsrSchedQid q, CsrUint16 mi, void *mv)
+void CsrSchedMessagePut(CsrSchedQid q, u16 mi, void *mv)
#endif
{
CsrWifiFsmEvent* evt = (CsrWifiFsmEvent*)mv;
/* Big endian :e.g WSC, TCLAS */
-void CsrUint16DesBigEndian(CsrUint16 *v, u8 *buffer, CsrSize *offset)
+void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset)
{
- CsrUint16 val;
+ u16 val;
val = (buffer[(*offset)] << 8) | (buffer[(*offset) + 1]);
*offset += 2;
/* Big endian :e.g WSC, TCLAS */
-void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, CsrUint16 v)
+void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, u16 v)
{
ptr[(*len)] = (u8)((v & 0xff00) >> 8);
ptr[(*len) + 1] = (u8)((v & 0x00ff));
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_SME_AP upstream message
*----------------------------------------------------------------------------*/
-void CsrWifiSmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiSmeApFreeUpstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* CsrWifiSmeApFreeDownstreamMessageContents
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_SME_AP downstream message
*----------------------------------------------------------------------------*/
-void CsrWifiSmeApFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiSmeApFreeDownstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* Enum to string functions
msg__->secIeLength = (secIeLength__); \
msg__->secIe = (secIe__); \
msg__->groupKeyId = (groupKeyId__); \
- CsrMemCpy(msg__->seqNumber, (seqNumber__), sizeof(CsrUint16) * 8);
+ CsrMemCpy(msg__->seqNumber, (seqNumber__), sizeof(u16) * 8);
#define CsrWifiSmeApStaNotifyIndSendTo(dst__, src__, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__, disassocReason__, deauthReason__, WpsRegistration__, secIeLength__, secIe__, groupKeyId__, seqNumber__) \
{ \
Set to 0 for the current release
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeApRsnCapabilities;
+typedef u16 CsrWifiSmeApRsnCapabilities;
/*******************************************************************************
NAME
Mask type for use with the values defined by CsrWifiSmeApRsnCapabilities
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeApRsnCapabilitiesMask;
+typedef u16 CsrWifiSmeApRsnCapabilitiesMask;
/*******************************************************************************
NAME
current release
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeApWapiCapabilities;
+typedef u16 CsrWifiSmeApWapiCapabilities;
/*******************************************************************************
NAME
Mask type for use with the values defined by CsrWifiSmeApWapiCapabilities
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeApWapiCapabilitiesMask;
+typedef u16 CsrWifiSmeApWapiCapabilitiesMask;
/*******************************************************************************
typedef struct
{
CsrWifiSmeApPhySupportMask phySupportedBitmap;
- CsrUint16 beaconInterval;
+ u16 beaconInterval;
u8 dtimPeriod;
- CsrUint16 maxListenInterval;
+ u16 maxListenInterval;
u8 supportedRatesCount;
u8 supportedRates[20];
CsrWifiSmePreambleType preamble;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 initialPresence;
CsrWifiSmeApType apType;
CsrBool cloakSsid;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeApBeaconingStopReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeWpsDpid SelectedDevicePasswordId;
CsrWifiSmeWpsConfigType SelectedconfigMethod;
} CsrWifiSmeApWpsRegistrationStartedReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeApWpsRegistrationFinishedReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeWmmAcParams wmmApParams[4];
CsrWifiSmeWmmAcParams wmmApBcParams[4];
} CsrWifiSmeApWmmParamUpdateReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeIEEE80211Reason deauthReason;
CsrWifiSmeIEEE80211Reason disassocReason;
CsrWifiMacAddress peerMacaddress;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeApActiveBaGetReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeIEEE80211Reason reason;
CsrWifiSmeApBaSession baSession;
} CsrWifiSmeApBaDeleteReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
- CsrUint16 secIeLength;
+ u16 secIeLength;
u8 *secIe;
} CsrWifiSmeApBeaconingStartCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeApBeaconingStopCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeMediaStatus mediaStatus;
CsrWifiMacAddress peerMacAddress;
CsrWifiMacAddress peerDeviceAddress;
u8 secIeLength;
u8 *secIe;
u8 groupKeyId;
- CsrUint16 seqNumber[8];
+ u16 seqNumber[8];
} CsrWifiSmeApStaNotifyInd;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress peerMacAddress;
} CsrWifiSmeApStaConnectStartInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeApWpsRegistrationStartedCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeApWpsRegistrationFinishedCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeApWmmParamUpdateCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiMacAddress peerMacaddress;
} CsrWifiSmeApStaDisconnectCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeApType apType;
CsrResult status;
} CsrWifiSmeApErrorInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
- CsrUint16 activeBaCount;
+ u16 activeBaCount;
CsrWifiSmeApBaSession *activeBaSessions;
} CsrWifiSmeApActiveBaGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeApBaSession baSession;
} CsrWifiSmeApBaDeleteCfm;
{ 0, NULL, NULL, NULL, NULL },
};
-CsrMsgConvMsgEntry* CsrWifiSmeConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+CsrMsgConvMsgEntry* CsrWifiSmeConverterLookup(CsrMsgConvMsgEntry *ce, u16 msgType)
{
if (msgType & CSR_PRIM_UPSTREAM)
{
- CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT;
+ u16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT;
if (idx < (CSR_WIFI_SME_PRIM_UPSTREAM_COUNT + CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT) &&
csrwifisme_conv_lut[idx].msgType == msgType)
{
* eventClass: only the value CSR_WIFI_SME_PRIM will be handled
* message: the message to free
*----------------------------------------------------------------------------*/
-void CsrWifiSmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiSmeFreeDownstreamMessageContents(u16 eventClass, void *message)
{
if (eventClass != CSR_WIFI_SME_PRIM)
{
{
CsrWifiSmeWifiFlightmodeReq *p = (CsrWifiSmeWifiFlightmodeReq *)message;
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < p->mibFilesCount; i1++)
{
CsrPmemFree(p->mibFiles[i1].data);
{
CsrWifiSmeWifiOnReq *p = (CsrWifiSmeWifiOnReq *)message;
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < p->mibFilesCount; i1++)
{
CsrPmemFree(p->mibFiles[i1].data);
* eventClass: only the value CSR_WIFI_SME_PRIM will be handled
* message: the message to free
*----------------------------------------------------------------------------*/
-void CsrWifiSmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiSmeFreeUpstreamMessageContents(u16 eventClass, void *message)
{
if (eventClass != CSR_WIFI_SME_PRIM)
{
{
case CSR_WIFI_SME_P2P_ROLE_GO:
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < p->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
CsrPmemFree(p->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
{
CsrWifiSmeScanResultsGetCfm *p = (CsrWifiSmeScanResultsGetCfm *)message;
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < p->scanResultsCount; i1++)
{
CsrPmemFree(p->scanResults[i1].informationElements);
{
case CSR_WIFI_SME_P2P_ROLE_GO:
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < p->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
CsrPmemFree(p->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_SME upstream message
*----------------------------------------------------------------------------*/
-void CsrWifiSmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiSmeFreeUpstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* CsrWifiSmeFreeDownstreamMessageContents
* PARAMETERS
* Deallocates the resources in a CSR_WIFI_SME downstream message
*----------------------------------------------------------------------------*/
-void CsrWifiSmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiSmeFreeDownstreamMessageContents(u16 eventClass, void *message);
/*----------------------------------------------------------------------------*
* Enum to string functions
- For future use.
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeAuthMode;
+typedef u16 CsrWifiSmeAuthMode;
#define CSR_WIFI_SME_AUTH_MODE_80211_OPEN ((CsrWifiSmeAuthMode) 0x0001)
#define CSR_WIFI_SME_AUTH_MODE_80211_SHARED ((CsrWifiSmeAuthMode) 0x0002)
#define CSR_WIFI_SME_AUTH_MODE_8021X_WPA ((CsrWifiSmeAuthMode) 0x0004)
- Selects SMS4 for broadcast messages
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeEncryption;
+typedef u16 CsrWifiSmeEncryption;
#define CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE ((CsrWifiSmeEncryption) 0x0000)
#define CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP40 ((CsrWifiSmeEncryption) 0x0001)
#define CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP104 ((CsrWifiSmeEncryption) 0x0002)
- See IEEE 802.11 Standard
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeIEEE80211Reason;
+typedef u16 CsrWifiSmeIEEE80211Reason;
#define CSR_WIFI_SME_IEEE80211_REASON_SUCCESS ((CsrWifiSmeIEEE80211Reason) 0x0000)
#define CSR_WIFI_SME_IEEE80211_REASON_UNSPECIFIED_REASON ((CsrWifiSmeIEEE80211Reason) 0x0001)
#define CSR_WIFI_SME_IEEE80211_REASON_AUTHENTICATION_NOT_VALID ((CsrWifiSmeIEEE80211Reason) 0x0002)
- See IEEE 802.11 Standard
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeIEEE80211Result;
+typedef u16 CsrWifiSmeIEEE80211Result;
#define CSR_WIFI_SME_IEEE80211_RESULT_SUCCESS ((CsrWifiSmeIEEE80211Result) 0x0000)
#define CSR_WIFI_SME_IEEE80211_RESULT_UNSPECIFIED_FAILURE ((CsrWifiSmeIEEE80211Result) 0x0001)
#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_CAPABILITIES_MISMATCH ((CsrWifiSmeIEEE80211Result) 0x000a)
- Physical Display : Attached to the device
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeWpsConfigType;
+typedef u16 CsrWifiSmeWpsConfigType;
#define CSR_WIFI_WPS_CONFIG_LABEL ((CsrWifiSmeWpsConfigType) 0x0004)
#define CSR_WIFI_WPS_CONFIG_DISPLAY ((CsrWifiSmeWpsConfigType) 0x0008)
#define CSR_WIFI_WPS_CONFIG_EXT_NFC ((CsrWifiSmeWpsConfigType) 0x0010)
negotiation procedure
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeWpsDpid;
+typedef u16 CsrWifiSmeWpsDpid;
#define CSR_WIFI_SME_WPS_DPID_PIN ((CsrWifiSmeWpsDpid) 0x0000)
#define CSR_WIFI_SME_WPS_DPID_USER ((CsrWifiSmeWpsDpid) 0x0001)
#define CSR_WIFI_SME_WPS_DPID_MACHINE ((CsrWifiSmeWpsDpid) 0x0002)
Mask type for use with the values defined by CsrWifiSmeAuthMode
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeAuthModeMask;
+typedef u16 CsrWifiSmeAuthModeMask;
/*******************************************************************************
NAME
Mask type for use with the values defined by CsrWifiSmeEncryption
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeEncryptionMask;
+typedef u16 CsrWifiSmeEncryptionMask;
/*******************************************************************************
NAME
Mask type for use with the values defined by CsrWifiSmeWpsConfigType
*******************************************************************************/
-typedef CsrUint16 CsrWifiSmeWpsConfigTypeMask;
+typedef u16 CsrWifiSmeWpsConfigTypeMask;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint16 atimWindowTu;
- CsrUint16 beaconPeriodTu;
- CsrUint16 joinOnlyAttempts;
- CsrUint16 joinAttemptIntervalMs;
+ u16 atimWindowTu;
+ u16 beaconPeriodTu;
+ u16 joinOnlyAttempts;
+ u16 joinAttemptIntervalMs;
} CsrWifiSmeAdHocConfig;
/*******************************************************************************
typedef struct
{
u8 listenChannel;
- CsrUint16 availabilityDuration;
- CsrUint16 avalabilityPeriod;
+ u16 availabilityDuration;
+ u16 avalabilityPeriod;
} CsrWifiSmeAvailabilityConfig;
/*******************************************************************************
{
CsrBool coexEnableSchemeManagement;
CsrBool coexPeriodicWakeHost;
- CsrUint16 coexTrafficBurstyLatencyMs;
- CsrUint16 coexTrafficContinuousLatencyMs;
- CsrUint16 coexObexBlackoutDurationMs;
- CsrUint16 coexObexBlackoutPeriodMs;
- CsrUint16 coexA2dpBrBlackoutDurationMs;
- CsrUint16 coexA2dpBrBlackoutPeriodMs;
- CsrUint16 coexA2dpEdrBlackoutDurationMs;
- CsrUint16 coexA2dpEdrBlackoutPeriodMs;
- CsrUint16 coexPagingBlackoutDurationMs;
- CsrUint16 coexPagingBlackoutPeriodMs;
- CsrUint16 coexInquiryBlackoutDurationMs;
- CsrUint16 coexInquiryBlackoutPeriodMs;
+ u16 coexTrafficBurstyLatencyMs;
+ u16 coexTrafficContinuousLatencyMs;
+ u16 coexObexBlackoutDurationMs;
+ u16 coexObexBlackoutPeriodMs;
+ u16 coexA2dpBrBlackoutDurationMs;
+ u16 coexA2dpBrBlackoutPeriodMs;
+ u16 coexA2dpEdrBlackoutDurationMs;
+ u16 coexA2dpEdrBlackoutPeriodMs;
+ u16 coexPagingBlackoutDurationMs;
+ u16 coexPagingBlackoutPeriodMs;
+ u16 coexInquiryBlackoutDurationMs;
+ u16 coexInquiryBlackoutPeriodMs;
} CsrWifiSmeCoexConfig;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint16 length;
+ u16 length;
u8 *data;
} CsrWifiSmeDataBlock;
{
CsrBool unifiFixMaxTxDataRate;
u8 unifiFixTxDataRate;
- CsrUint16 dot11RtsThreshold;
- CsrUint16 dot11FragmentationThreshold;
- CsrUint16 dot11CurrentTxPowerLevel;
+ u16 dot11RtsThreshold;
+ u16 dot11FragmentationThreshold;
+ u16 dot11CurrentTxPowerLevel;
} CsrWifiSmeMibConfig;
/*******************************************************************************
typedef struct
{
u8 listenChannel;
- CsrUint16 availabilityDuration;
- CsrUint16 avalabilityPeriod;
+ u16 availabilityDuration;
+ u16 avalabilityPeriod;
} CsrWifiSmeP2pProfileIdentity;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint16 intervalSeconds;
- CsrUint16 validitySeconds;
- CsrUint16 minActiveChannelTimeTu;
- CsrUint16 maxActiveChannelTimeTu;
- CsrUint16 minPassiveChannelTimeTu;
- CsrUint16 maxPassiveChannelTimeTu;
+ u16 intervalSeconds;
+ u16 validitySeconds;
+ u16 minActiveChannelTimeTu;
+ u16 maxActiveChannelTimeTu;
+ u16 minPassiveChannelTimeTu;
+ u16 maxPassiveChannelTimeTu;
} CsrWifiSmeScanConfigData;
/*******************************************************************************
u8 cwMin;
u8 cwMax;
u8 aifs;
- CsrUint16 txopLimit;
+ u16 txopLimit;
CsrBool admissionControlMandatory;
} CsrWifiSmeWmmAcParams;
*******************************************************************************/
typedef struct
{
- CsrUint16 version;
- CsrUint16 configMethods;
- CsrUint16 devicePassworId;
+ u16 version;
+ u16 configMethods;
+ u16 devicePassworId;
} CsrWifiSmeWpsInfo;
/*******************************************************************************
{
CsrBool hasTrafficData;
CsrWifiSmeTrafficType currentTrafficType;
- CsrUint16 currentPeriodMs;
+ u16 currentPeriodMs;
CsrWifiSmePowerSaveLevel currentPowerSave;
- CsrUint16 currentCoexPeriodMs;
- CsrUint16 currentCoexLatencyMs;
+ u16 currentCoexPeriodMs;
+ u16 currentCoexLatencyMs;
CsrBool hasBtDevice;
CsrUint32 currentBlackoutDurationUs;
CsrUint32 currentBlackoutPeriodUs;
CsrWifiSme80211PrivacyMode privacyMode;
CsrWifiSmeAuthModeMask authModeMask;
CsrWifiSmeEncryptionMask encryptionModeMask;
- CsrUint16 mlmeAssociateReqInformationElementsLength;
+ u16 mlmeAssociateReqInformationElementsLength;
u8 *mlmeAssociateReqInformationElements;
CsrWifiSmeWmmQosInfoMask wmmQosInfo;
CsrBool adhocJoinOnly;
CsrWifiMacAddress bssid;
CsrWifiSme80211NetworkType networkType80211;
u8 channelNumber;
- CsrUint16 channelFrequency;
+ u16 channelFrequency;
CsrWifiSmeAuthMode authMode;
CsrWifiSmeEncryption pairwiseCipher;
CsrWifiSmeEncryption groupCipher;
CsrWifiSmeRadioIF ifIndex;
- CsrUint16 atimWindowTu;
- CsrUint16 beaconPeriodTu;
+ u16 atimWindowTu;
+ u16 beaconPeriodTu;
CsrBool reassociation;
- CsrUint16 beaconFrameLength;
+ u16 beaconFrameLength;
u8 *beaconFrame;
- CsrUint16 associationReqFrameLength;
+ u16 associationReqFrameLength;
u8 *associationReqFrame;
- CsrUint16 associationRspFrameLength;
+ u16 associationRspFrameLength;
u8 *associationRspFrame;
- CsrUint16 assocScanInfoElementsLength;
+ u16 assocScanInfoElementsLength;
u8 *assocScanInfoElements;
- CsrUint16 assocReqCapabilities;
- CsrUint16 assocReqListenIntervalTu;
+ u16 assocReqCapabilities;
+ u16 assocReqListenIntervalTu;
CsrWifiMacAddress assocReqApAddress;
- CsrUint16 assocReqInfoElementsLength;
+ u16 assocReqInfoElementsLength;
u8 *assocReqInfoElements;
CsrWifiSmeIEEE80211Result assocRspResult;
- CsrUint16 assocRspCapabilityInfo;
- CsrUint16 assocRspAssociationId;
- CsrUint16 assocRspInfoElementsLength;
+ u16 assocRspCapabilityInfo;
+ u16 assocRspAssociationId;
+ u16 assocRspInfoElementsLength;
u8 *assocRspInfoElements;
} CsrWifiSmeConnectionInfo;
typedef struct
{
CsrWifiSmeHostPowerMode powerMode;
- CsrUint16 applicationDataPeriodMs;
+ u16 applicationDataPeriodMs;
} CsrWifiSmeHostConfig;
/*******************************************************************************
CsrWifiSmeKeyType keyType;
u8 keyIndex;
CsrBool wepTxKey;
- CsrUint16 keyRsc[8];
+ u16 keyRsc[8];
CsrBool authenticator;
CsrWifiMacAddress address;
u8 keyLength;
typedef struct
{
CsrWifiSmePowerSaveLevel powerSaveLevel;
- CsrUint16 listenIntervalTu;
+ u16 listenIntervalTu;
CsrBool rxDtims;
CsrWifiSmeD3AutoScanMode d3AutoScanMode;
u8 clientTrafficWindow;
CsrBool disableSmoothRoaming;
CsrBool disableRoamScans;
u8 reconnectLimit;
- CsrUint16 reconnectLimitIntervalMs;
+ u16 reconnectLimitIntervalMs;
CsrWifiSmeScanConfigData roamScanCfg[3];
} CsrWifiSmeRoamingConfig;
{
CsrWifiSmeScanConfigData scanCfg[4];
CsrBool disableAutonomousScans;
- CsrUint16 maxResults;
+ u16 maxResults;
s8 highRssiThreshold;
s8 lowRssiThreshold;
s8 deltaRssiThreshold;
s8 highSnrThreshold;
s8 lowSnrThreshold;
s8 deltaSnrThreshold;
- CsrUint16 passiveChannelListCount;
+ u16 passiveChannelListCount;
u8 *passiveChannelList;
} CsrWifiSmeScanConfig;
CsrInt16 rssi;
CsrInt16 snr;
CsrWifiSmeRadioIF ifIndex;
- CsrUint16 beaconPeriodTu;
+ u16 beaconPeriodTu;
CsrWifiSmeTsfTime timeStamp;
CsrWifiSmeTsfTime localTime;
- CsrUint16 channelFrequency;
- CsrUint16 capabilityInformation;
+ u16 channelFrequency;
+ u16 capabilityInformation;
u8 channelNumber;
CsrWifiSmeBasicUsability usability;
CsrWifiSmeBssType bssType;
- CsrUint16 informationElementsLength;
+ u16 informationElementsLength;
u8 *informationElements;
CsrWifiSmeP2pRole p2pDeviceRole;
union {
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeListAction action;
u8 setAddressCount;
CsrWifiMacAddress *setAddresses;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 calibrationDataLength;
+ u16 calibrationDataLength;
u8 *calibrationData;
} CsrWifiSmeCalibrationDataSetReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeCcxConfigGetReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeCcxConfig ccxConfig;
} CsrWifiSmeCcxConfigSetReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeConnectionConfig connectionConfig;
} CsrWifiSmeConnectReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeConnectionConfigGetReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeConnectionInfoGetReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeConnectionStatsGetReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeDisconnectReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeHostConfigGetReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeHostConfig hostConfig;
} CsrWifiSmeHostConfigSetReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeListAction action;
CsrWifiSmeKey key;
} CsrWifiSmeKeyReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeLinkQualityGetReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 mibAttributeLength;
+ u16 mibAttributeLength;
u8 *mibAttribute;
} CsrWifiSmeMibGetNextReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 mibAttributeLength;
+ u16 mibAttributeLength;
u8 *mibAttribute;
} CsrWifiSmeMibGetReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 mibAttributeLength;
+ u16 mibAttributeLength;
u8 *mibAttribute;
} CsrWifiSmeMibSetReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeListAction action;
u8 setAddressesCount;
CsrWifiMacAddress *setAddresses;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
- CsrUint16 filterLength;
+ u16 interfaceTag;
+ u16 filterLength;
u8 *filter;
CsrWifiSmePacketFilterMode mode;
CsrWifiIp4Address arpFilterAddress;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeListAction action;
u8 setPmkidsCount;
CsrWifiSmePmkid *setPmkids;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeRoamingConfigGetReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeRoamingConfig roamingConfig;
} CsrWifiSmeRoamingConfigSetReq;
CsrBool forceScan;
CsrWifiSmeBssType bssType;
CsrWifiSmeScanType scanType;
- CsrUint16 channelListCount;
+ u16 channelListCount;
u8 *channelList;
- CsrUint16 probeIeLength;
+ u16 probeIeLength;
u8 *probeIe;
} CsrWifiSmeScanFullReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
} CsrWifiSmeSmeStaConfigGetReq;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeStaConfig smeConfig;
} CsrWifiSmeSmeStaConfigSetReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeListAction action;
CsrUint32 transactionId;
CsrBool strict;
CsrWifiSmeTspecCtrlMask ctrlMask;
- CsrUint16 tspecLength;
+ u16 tspecLength;
u8 *tspec;
- CsrUint16 tclasLength;
+ u16 tclasLength;
u8 *tclas;
} CsrWifiSmeTspecReq;
{
CsrWifiFsmEvent common;
CsrWifiMacAddress address;
- CsrUint16 mibFilesCount;
+ u16 mibFilesCount;
CsrWifiSmeDataBlock *mibFiles;
} CsrWifiSmeWifiFlightmodeReq;
{
CsrWifiFsmEvent common;
CsrWifiMacAddress address;
- CsrUint16 mibFilesCount;
+ u16 mibFilesCount;
CsrWifiSmeDataBlock *mibFiles;
} CsrWifiSmeWifiOnReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeConnectionInfo connectionInfo;
CsrWifiSmeIEEE80211Reason deauthReason;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress address;
CsrWifiSsid ssid;
} CsrWifiSmeAssociationStartInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeListAction action;
u8 getAddressCount;
{
CsrWifiFsmEvent common;
CsrResult status;
- CsrUint16 calibrationDataLength;
+ u16 calibrationDataLength;
u8 *calibrationData;
} CsrWifiSmeCalibrationDataGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeCcxConfig ccxConfig;
} CsrWifiSmeCcxConfigGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeCcxConfigSetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeConnectCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeConnectionConfig connectionConfig;
} CsrWifiSmeConnectionConfigGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeConnectionInfo connectionInfo;
} CsrWifiSmeConnectionInfoGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeLinkQuality linkQuality;
} CsrWifiSmeConnectionQualityInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeConnectionStats connectionStats;
} CsrWifiSmeConnectionStatsGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeDisconnectCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeHostConfig hostConfig;
} CsrWifiSmeHostConfigGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeHostConfigSetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeListAction action;
CsrWifiSmeKeyType keyType;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeLinkQuality linkQuality;
} CsrWifiSmeLinkQualityGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeMediaStatus mediaStatus;
CsrWifiSmeConnectionInfo connectionInfo;
CsrWifiSmeIEEE80211Reason disassocReason;
{
CsrWifiFsmEvent common;
CsrResult status;
- CsrUint16 mibAttributeLength;
+ u16 mibAttributeLength;
u8 *mibAttribute;
} CsrWifiSmeMibGetCfm;
{
CsrWifiFsmEvent common;
CsrResult status;
- CsrUint16 mibAttributeLength;
+ u16 mibAttributeLength;
u8 *mibAttribute;
} CsrWifiSmeMibGetNextCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrBool secondFailure;
- CsrUint16 count;
+ u16 count;
CsrWifiMacAddress address;
CsrWifiSmeKeyType keyType;
} CsrWifiSmeMicFailureInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeListAction action;
u8 getAddressesCount;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmePacketFilterSetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 pmkidCandidatesCount;
CsrWifiSmePmkidCandidate *pmkidCandidates;
} CsrWifiSmePmkidCandidateListInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeListAction action;
u8 getPmkidsCount;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeRoamCompleteInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeRoamReason roamReason;
CsrWifiSmeIEEE80211Reason reason80211;
} CsrWifiSmeRoamStartInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeRoamingConfig roamingConfig;
} CsrWifiSmeRoamingConfigGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeRoamingConfigSetCfm;
{
CsrWifiFsmEvent common;
CsrResult status;
- CsrUint16 scanResultsCount;
+ u16 scanResultsCount;
CsrWifiSmeScanResult *scanResults;
} CsrWifiSmeScanResultsGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrWifiSmeStaConfig smeConfig;
} CsrWifiSmeSmeStaConfigGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
} CsrWifiSmeSmeStaConfigSetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrUint32 transactionId;
CsrWifiSmeTspecResultCode tspecResultCode;
- CsrUint16 tspecLength;
+ u16 tspecLength;
u8 *tspec;
} CsrWifiSmeTspecInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrResult status;
CsrUint32 transactionId;
CsrWifiSmeTspecResultCode tspecResultCode;
- CsrUint16 tspecLength;
+ u16 tspecLength;
u8 *tspec;
} CsrWifiSmeTspecCfm;
{
CsrWifiFsmEvent common;
CsrResult status;
- CsrUint16 numInterfaces;
+ u16 numInterfaces;
u8 capBitmap[2];
} CsrWifiSmeInterfaceCapabilityGetCfm;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiSmeAmpStatus ampStatus;
} CsrWifiSmeAmpStatusChangeInd;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
- bufferSize += 2; /* CsrUint16 primitive->adHocConfig.atimWindowTu */
- bufferSize += 2; /* CsrUint16 primitive->adHocConfig.beaconPeriodTu */
- bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinOnlyAttempts */
- bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinAttemptIntervalMs */
+ bufferSize += 2; /* u16 primitive->adHocConfig.atimWindowTu */
+ bufferSize += 2; /* u16 primitive->adHocConfig.beaconPeriodTu */
+ bufferSize += 2; /* u16 primitive->adHocConfig.joinOnlyAttempts */
+ bufferSize += 2; /* u16 primitive->adHocConfig.joinAttemptIntervalMs */
return bufferSize;
}
CsrWifiSmeAdhocConfigSetReq *primitive = (CsrWifiSmeAdhocConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.atimWindowTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.beaconPeriodTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinOnlyAttempts);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinAttemptIntervalMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.atimWindowTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.beaconPeriodTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.joinOnlyAttempts);
+ CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.joinAttemptIntervalMs);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.atimWindowTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.beaconPeriodTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinOnlyAttempts, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinAttemptIntervalMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->adHocConfig.atimWindowTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->adHocConfig.beaconPeriodTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->adHocConfig.joinOnlyAttempts, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->adHocConfig.joinAttemptIntervalMs, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 1; /* u8 primitive->setAddressCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setAddressCount; i1++)
{
bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint8Ser(ptr, len, (u8) primitive->setAddressCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setAddressCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((u16) (6)));
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint8Des((u8 *) &primitive->setAddressCount, buffer, &offset);
primitive->setAddresses = NULL;
primitive->setAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->setAddressCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setAddressCount; i1++)
{
- CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((u16) (6)));
}
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
- bufferSize += 2; /* CsrUint16 primitive->calibrationDataLength */
+ bufferSize += 2; /* u16 primitive->calibrationDataLength */
bufferSize += primitive->calibrationDataLength; /* u8 primitive->calibrationData */
return bufferSize;
}
CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->calibrationDataLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->calibrationDataLength);
if (primitive->calibrationDataLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->calibrationData, ((CsrUint16) (primitive->calibrationDataLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->calibrationData, ((u16) (primitive->calibrationDataLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->calibrationDataLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->calibrationDataLength, buffer, &offset);
if (primitive->calibrationDataLength)
{
primitive->calibrationData = (u8 *)CsrPmemAlloc(primitive->calibrationDataLength);
- CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((CsrUint16) (primitive->calibrationDataLength)));
+ CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((u16) (primitive->calibrationDataLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* u8 primitive->ccxConfig.keepAliveTimeMs */
bufferSize += 1; /* CsrBool primitive->ccxConfig.apRoamingEnabled */
bufferSize += 1; /* u8 primitive->ccxConfig.measurementsMask */
CsrWifiSmeCcxConfigSetReq *primitive = (CsrWifiSmeCcxConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.keepAliveTimeMs);
CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.apRoamingEnabled);
CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.measurementsMask);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
CsrUint8Des((u8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
CsrUint8Des((u8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 29) */
bufferSize += 1; /* CsrBool primitive->coexConfig.coexEnableSchemeManagement */
bufferSize += 1; /* CsrBool primitive->coexConfig.coexPeriodicWakeHost */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficBurstyLatencyMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficContinuousLatencyMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutDurationMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutPeriodMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutDurationMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutPeriodMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutDurationMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutDurationMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutPeriodMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutDurationMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexTrafficBurstyLatencyMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexTrafficContinuousLatencyMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexObexBlackoutDurationMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexObexBlackoutPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpBrBlackoutDurationMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpBrBlackoutPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpEdrBlackoutDurationMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexPagingBlackoutDurationMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexPagingBlackoutPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexInquiryBlackoutDurationMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexInquiryBlackoutPeriodMs */
return bufferSize;
}
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexEnableSchemeManagement);
CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexPeriodicWakeHost);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutDurationMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutPeriodMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutDurationMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutPeriodMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutDurationMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutDurationMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutPeriodMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutDurationMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexObexBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexObexBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpBrBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpBrBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpEdrBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexPagingBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexPagingBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexInquiryBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexInquiryBlackoutPeriodMs);
return(ptr);
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint8Des((u8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
CsrUint8Des((u8 *) &primitive->coexConfig.coexPeriodicWakeHost, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutPeriodMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutDurationMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutPeriodMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutDurationMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutDurationMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutPeriodMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutDurationMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexObexBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpBrBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpBrBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpEdrBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexPagingBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexPagingBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexInquiryBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexInquiryBlackoutPeriodMs, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 57) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 32; /* u8 primitive->connectionConfig.ssid.ssid[32] */
bufferSize += 1; /* u8 primitive->connectionConfig.ssid.length */
bufferSize += 6; /* u8 primitive->connectionConfig.bssid.a[6] */
bufferSize += 1; /* CsrWifiSme80211PrivacyMode primitive->connectionConfig.privacyMode */
bufferSize += 2; /* CsrWifiSmeAuthModeMask primitive->connectionConfig.authModeMask */
bufferSize += 2; /* CsrWifiSmeEncryptionMask primitive->connectionConfig.encryptionModeMask */
- bufferSize += 2; /* CsrUint16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* u8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
bufferSize += 1; /* CsrWifiSmeWmmQosInfoMask primitive->connectionConfig.wmmQosInfo */
bufferSize += 1; /* CsrBool primitive->connectionConfig.adhocJoinOnly */
CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((CsrUint16) (32)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ssid.length);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.bssType);
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ifIndex);
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.privacyMode);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.authModeMask);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.encryptionModeMask);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.authModeMask);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.encryptionModeMask);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((u16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
}
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.wmmQosInfo);
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocJoinOnly);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
- CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->connectionConfig.bssType, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
{
primitive->connectionConfig.mlmeAssociateReqInformationElements = (u8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
- CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+ CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((u16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeHostPowerMode primitive->hostConfig.powerMode */
- bufferSize += 2; /* CsrUint16 primitive->hostConfig.applicationDataPeriodMs */
+ bufferSize += 2; /* u16 primitive->hostConfig.applicationDataPeriodMs */
return bufferSize;
}
CsrWifiSmeHostConfigSetReq *primitive = (CsrWifiSmeHostConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->hostConfig.powerMode);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->hostConfig.applicationDataPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->hostConfig.applicationDataPeriodMs);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->hostConfig.powerMode, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 65) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 1; /* CsrWifiSmeKeyType primitive->key.keyType */
bufferSize += 1; /* u8 primitive->key.keyIndex */
bufferSize += 1; /* CsrBool primitive->key.wepTxKey */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 8; i2++)
{
- bufferSize += 2; /* CsrUint16 primitive->key.keyRsc[8] */
+ bufferSize += 2; /* u16 primitive->key.keyRsc[8] */
}
}
bufferSize += 1; /* CsrBool primitive->key.authenticator */
CsrWifiSmeKeyReq *primitive = (CsrWifiSmeKeyReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint8Ser(ptr, len, (u8) primitive->key.keyType);
CsrUint8Ser(ptr, len, (u8) primitive->key.keyIndex);
CsrUint8Ser(ptr, len, (u8) primitive->key.wepTxKey);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 8; i2++)
{
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->key.keyRsc[i2]);
+ CsrUint16Ser(ptr, len, (u16) primitive->key.keyRsc[i2]);
}
}
CsrUint8Ser(ptr, len, (u8) primitive->key.authenticator);
- CsrMemCpySer(ptr, len, (const void *) primitive->key.address.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->key.address.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->key.keyLength);
- CsrMemCpySer(ptr, len, (const void *) primitive->key.key, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->key.key, ((u16) (32)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint8Des((u8 *) &primitive->key.keyType, buffer, &offset);
CsrUint8Des((u8 *) &primitive->key.keyIndex, buffer, &offset);
CsrUint8Des((u8 *) &primitive->key.wepTxKey, buffer, &offset);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 8; i2++)
{
- CsrUint16Des((CsrUint16 *) &primitive->key.keyRsc[i2], buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->key.keyRsc[i2], buffer, &offset);
}
}
CsrUint8Des((u8 *) &primitive->key.authenticator, buffer, &offset);
- CsrMemCpyDes(primitive->key.address.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->key.address.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->key.keyLength, buffer, &offset);
- CsrMemCpyDes(primitive->key.key, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->key.key, buffer, &offset, ((u16) (32)));
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
bufferSize += 1; /* CsrBool primitive->mibConfig.unifiFixMaxTxDataRate */
bufferSize += 1; /* u8 primitive->mibConfig.unifiFixTxDataRate */
- bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11RtsThreshold */
- bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11FragmentationThreshold */
- bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11CurrentTxPowerLevel */
+ bufferSize += 2; /* u16 primitive->mibConfig.dot11RtsThreshold */
+ bufferSize += 2; /* u16 primitive->mibConfig.dot11FragmentationThreshold */
+ bufferSize += 2; /* u16 primitive->mibConfig.dot11CurrentTxPowerLevel */
return bufferSize;
}
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixMaxTxDataRate);
CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixTxDataRate);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11RtsThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11FragmentationThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11CurrentTxPowerLevel);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11RtsThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11FragmentationThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11CurrentTxPowerLevel);
return(ptr);
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixTxDataRate, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
- bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
+ bufferSize += 2; /* u16 primitive->mibAttributeLength */
bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
return bufferSize;
}
CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibAttributeLength);
if (primitive->mibAttributeLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((u16) (primitive->mibAttributeLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibAttributeLength, buffer, &offset);
if (primitive->mibAttributeLength)
{
primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
- CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+ CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((u16) (primitive->mibAttributeLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
- bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
+ bufferSize += 2; /* u16 primitive->mibAttributeLength */
bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
return bufferSize;
}
CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibAttributeLength);
if (primitive->mibAttributeLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((u16) (primitive->mibAttributeLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibAttributeLength, buffer, &offset);
if (primitive->mibAttributeLength)
{
primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
- CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+ CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((u16) (primitive->mibAttributeLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
- bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
+ bufferSize += 2; /* u16 primitive->mibAttributeLength */
bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
return bufferSize;
}
CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibAttributeLength);
if (primitive->mibAttributeLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((u16) (primitive->mibAttributeLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibAttributeLength, buffer, &offset);
if (primitive->mibAttributeLength)
{
primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
- CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+ CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((u16) (primitive->mibAttributeLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 1; /* u8 primitive->setAddressesCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
{
bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint8Ser(ptr, len, (u8) primitive->setAddressesCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((u16) (6)));
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint8Des((u8 *) &primitive->setAddressesCount, buffer, &offset);
primitive->setAddresses = NULL;
primitive->setAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->setAddressesCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
{
- CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((u16) (6)));
}
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 2; /* CsrUint16 primitive->filterLength */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->filterLength */
bufferSize += primitive->filterLength; /* u8 primitive->filter */
bufferSize += 1; /* CsrWifiSmePacketFilterMode primitive->mode */
bufferSize += 4; /* u8 primitive->arpFilterAddress.a[4] */
CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->filterLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->filterLength);
if (primitive->filterLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->filter, ((CsrUint16) (primitive->filterLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->filter, ((u16) (primitive->filterLength)));
}
CsrUint8Ser(ptr, len, (u8) primitive->mode);
- CsrMemCpySer(ptr, len, (const void *) primitive->arpFilterAddress.a, ((CsrUint16) (4)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->arpFilterAddress.a, ((u16) (4)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->filterLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->filterLength, buffer, &offset);
if (primitive->filterLength)
{
primitive->filter = (u8 *)CsrPmemAlloc(primitive->filterLength);
- CsrMemCpyDes(primitive->filter, buffer, &offset, ((CsrUint16) (primitive->filterLength)));
+ CsrMemCpyDes(primitive->filter, buffer, &offset, ((u16) (primitive->filterLength)));
}
else
{
primitive->filter = NULL;
}
CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
- CsrMemCpyDes(primitive->arpFilterAddress.a, buffer, &offset, ((CsrUint16) (4)));
+ CsrMemCpyDes(primitive->arpFilterAddress.a, buffer, &offset, ((u16) (4)));
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 29) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 1; /* u8 primitive->setPmkidsCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
{
bufferSize += 6; /* u8 primitive->setPmkids[i1].bssid.a[6] */
CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint8Ser(ptr, len, (u8) primitive->setPmkidsCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->setPmkids[i1].bssid.a, ((CsrUint16) (6)));
- CsrMemCpySer(ptr, len, (const void *) primitive->setPmkids[i1].pmkid, ((CsrUint16) (16)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->setPmkids[i1].bssid.a, ((u16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->setPmkids[i1].pmkid, ((u16) (16)));
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint8Des((u8 *) &primitive->setPmkidsCount, buffer, &offset);
primitive->setPmkids = NULL;
primitive->setPmkids = (CsrWifiSmePmkid *)CsrPmemAlloc(sizeof(CsrWifiSmePmkid) * primitive->setPmkidsCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
{
- CsrMemCpyDes(primitive->setPmkids[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrMemCpyDes(primitive->setPmkids[i1].pmkid, buffer, &offset, ((CsrUint16) (16)));
+ CsrMemCpyDes(primitive->setPmkids[i1].bssid.a, buffer, &offset, ((u16) (6)));
+ CsrMemCpyDes(primitive->setPmkids[i1].pmkid, buffer, &offset, ((u16) (16)));
}
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
bufferSize += 1; /* CsrWifiSmePowerSaveLevel primitive->powerConfig.powerSaveLevel */
- bufferSize += 2; /* CsrUint16 primitive->powerConfig.listenIntervalTu */
+ bufferSize += 2; /* u16 primitive->powerConfig.listenIntervalTu */
bufferSize += 1; /* CsrBool primitive->powerConfig.rxDtims */
bufferSize += 1; /* CsrWifiSmeD3AutoScanMode primitive->powerConfig.d3AutoScanMode */
bufferSize += 1; /* u8 primitive->powerConfig.clientTrafficWindow */
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.powerSaveLevel);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->powerConfig.listenIntervalTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->powerConfig.listenIntervalTu);
CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.rxDtims);
CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.d3AutoScanMode);
CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.clientTrafficWindow);
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint8Des((u8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
CsrUint8Des((u8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
CsrUint8Des((u8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
CsrUint8Des((u8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 70) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].rssiHighThreshold */
bufferSize += 1; /* CsrBool primitive->roamingConfig.disableSmoothRoaming */
bufferSize += 1; /* CsrBool primitive->roamingConfig.disableRoamScans */
bufferSize += 1; /* u8 primitive->roamingConfig.reconnectLimit */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.reconnectLimitIntervalMs */
+ bufferSize += 2; /* u16 primitive->roamingConfig.reconnectLimitIntervalMs */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].intervalSeconds */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].validitySeconds */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].intervalSeconds */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].validitySeconds */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu */
}
}
return bufferSize;
CsrWifiSmeRoamingConfigSetReq *primitive = (CsrWifiSmeRoamingConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiHighThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiLowThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrHighThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].rssiHighThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].rssiLowThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].snrHighThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
}
}
CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableSmoothRoaming);
CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableRoamScans);
CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.reconnectLimit);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.reconnectLimitIntervalMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.reconnectLimitIntervalMs);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].intervalSeconds);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].validitySeconds);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].intervalSeconds);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].validitySeconds);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu);
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiHighThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiLowThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrHighThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].rssiHighThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].rssiLowThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].snrHighThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
}
}
CsrUint8Des((u8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
CsrUint8Des((u8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
CsrUint8Des((u8 *) &primitive->roamingConfig.reconnectLimit, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].intervalSeconds, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].validitySeconds, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].intervalSeconds, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].validitySeconds, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
}
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 63) */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].intervalSeconds */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].validitySeconds */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].intervalSeconds */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].validitySeconds */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu */
}
}
bufferSize += 1; /* CsrBool primitive->scanConfig.disableAutonomousScans */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.maxResults */
+ bufferSize += 2; /* u16 primitive->scanConfig.maxResults */
bufferSize += 1; /* s8 primitive->scanConfig.highRssiThreshold */
bufferSize += 1; /* s8 primitive->scanConfig.lowRssiThreshold */
bufferSize += 1; /* s8 primitive->scanConfig.deltaRssiThreshold */
bufferSize += 1; /* s8 primitive->scanConfig.highSnrThreshold */
bufferSize += 1; /* s8 primitive->scanConfig.lowSnrThreshold */
bufferSize += 1; /* s8 primitive->scanConfig.deltaSnrThreshold */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.passiveChannelListCount */
+ bufferSize += 2; /* u16 primitive->scanConfig.passiveChannelListCount */
bufferSize += primitive->scanConfig.passiveChannelListCount; /* u8 primitive->scanConfig.passiveChannelList */
return bufferSize;
}
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].intervalSeconds);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].validitySeconds);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].intervalSeconds);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].validitySeconds);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
}
}
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.disableAutonomousScans);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.maxResults);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.maxResults);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highRssiThreshold);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowRssiThreshold);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaRssiThreshold);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highSnrThreshold);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowSnrThreshold);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaSnrThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.passiveChannelListCount);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.passiveChannelListCount);
if (primitive->scanConfig.passiveChannelListCount)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->scanConfig.passiveChannelList, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanConfig.passiveChannelList, ((u16) (primitive->scanConfig.passiveChannelListCount)));
}
return(ptr);
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].intervalSeconds, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].validitySeconds, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].intervalSeconds, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].validitySeconds, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
}
}
CsrUint8Des((u8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.maxResults, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.maxResults, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.deltaSnrThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
if (primitive->scanConfig.passiveChannelListCount)
{
primitive->scanConfig.passiveChannelList = (u8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
- CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+ CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((u16) (primitive->scanConfig.passiveChannelListCount)));
}
else
{
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 52) */
bufferSize += 1; /* u8 primitive->ssidCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->ssidCount; i1++)
{
bufferSize += 32; /* u8 primitive->ssid[i1].ssid[32] */
bufferSize += 1; /* CsrBool primitive->forceScan */
bufferSize += 1; /* CsrWifiSmeBssType primitive->bssType */
bufferSize += 1; /* CsrWifiSmeScanType primitive->scanType */
- bufferSize += 2; /* CsrUint16 primitive->channelListCount */
+ bufferSize += 2; /* u16 primitive->channelListCount */
bufferSize += primitive->channelListCount; /* u8 primitive->channelList */
- bufferSize += 2; /* CsrUint16 primitive->probeIeLength */
+ bufferSize += 2; /* u16 primitive->probeIeLength */
bufferSize += primitive->probeIeLength; /* u8 primitive->probeIe */
return bufferSize;
}
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint8Ser(ptr, len, (u8) primitive->ssidCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->ssidCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->ssid[i1].ssid, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->ssid[i1].ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->ssid[i1].length);
}
}
- CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->forceScan);
CsrUint8Ser(ptr, len, (u8) primitive->bssType);
CsrUint8Ser(ptr, len, (u8) primitive->scanType);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->channelListCount);
+ CsrUint16Ser(ptr, len, (u16) primitive->channelListCount);
if (primitive->channelListCount)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->channelList, ((CsrUint16) (primitive->channelListCount)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->channelList, ((u16) (primitive->channelListCount)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->probeIeLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->probeIeLength);
if (primitive->probeIeLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->probeIe, ((CsrUint16) (primitive->probeIeLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->probeIe, ((u16) (primitive->probeIeLength)));
}
return(ptr);
}
primitive->ssid = (CsrWifiSsid *)CsrPmemAlloc(sizeof(CsrWifiSsid) * primitive->ssidCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->ssidCount; i1++)
{
- CsrMemCpyDes(primitive->ssid[i1].ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->ssid[i1].ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->ssid[i1].length, buffer, &offset);
}
}
- CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->forceScan, buffer, &offset);
CsrUint8Des((u8 *) &primitive->bssType, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanType, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->channelListCount, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->channelListCount, buffer, &offset);
if (primitive->channelListCount)
{
primitive->channelList = (u8 *)CsrPmemAlloc(primitive->channelListCount);
- CsrMemCpyDes(primitive->channelList, buffer, &offset, ((CsrUint16) (primitive->channelListCount)));
+ CsrMemCpyDes(primitive->channelList, buffer, &offset, ((u16) (primitive->channelListCount)));
}
else
{
primitive->channelList = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->probeIeLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->probeIeLength, buffer, &offset);
if (primitive->probeIeLength)
{
primitive->probeIe = (u8 *)CsrPmemAlloc(primitive->probeIeLength);
- CsrMemCpyDes(primitive->probeIe, buffer, &offset, ((CsrUint16) (primitive->probeIeLength)));
+ CsrMemCpyDes(primitive->probeIe, buffer, &offset, ((u16) (primitive->probeIeLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* u8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
bufferSize += 1; /* u8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
bufferSize += 1; /* CsrWifiSmeWmmModeMask primitive->smeConfig.wmmModeMask */
CsrWifiSmeSmeStaConfigSetReq *primitive = (CsrWifiSmeSmeStaConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.wmmModeMask);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
CsrUint8Des((u8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 4; /* CsrUint32 primitive->transactionId */
bufferSize += 1; /* CsrBool primitive->strict */
bufferSize += 1; /* CsrWifiSmeTspecCtrlMask primitive->ctrlMask */
- bufferSize += 2; /* CsrUint16 primitive->tspecLength */
+ bufferSize += 2; /* u16 primitive->tspecLength */
bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
- bufferSize += 2; /* CsrUint16 primitive->tclasLength */
+ bufferSize += 2; /* u16 primitive->tclasLength */
bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
return bufferSize;
}
CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
CsrUint8Ser(ptr, len, (u8) primitive->strict);
CsrUint8Ser(ptr, len, (u8) primitive->ctrlMask);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->tspecLength);
if (primitive->tspecLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((CsrUint16) (primitive->tspecLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((u16) (primitive->tspecLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->tclasLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->tclasLength);
if (primitive->tclasLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((CsrUint16) (primitive->tclasLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((u16) (primitive->tclasLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
CsrUint8Des((u8 *) &primitive->strict, buffer, &offset);
CsrUint8Des((u8 *) &primitive->ctrlMask, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->tspecLength, buffer, &offset);
if (primitive->tspecLength)
{
primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
- CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
+ CsrMemCpyDes(primitive->tspec, buffer, &offset, ((u16) (primitive->tspecLength)));
}
else
{
primitive->tspec = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->tclasLength, buffer, &offset);
if (primitive->tclasLength)
{
primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
- CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
+ CsrMemCpyDes(primitive->tclas, buffer, &offset, ((u16) (primitive->tclasLength)));
}
else
{
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
bufferSize += 6; /* u8 primitive->address.a[6] */
- bufferSize += 2; /* CsrUint16 primitive->mibFilesCount */
+ bufferSize += 2; /* u16 primitive->mibFilesCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
{
- bufferSize += 2; /* CsrUint16 primitive->mibFiles[i1].length */
+ bufferSize += 2; /* u16 primitive->mibFiles[i1].length */
bufferSize += primitive->mibFiles[i1].length; /* u8 primitive->mibFiles[i1].data */
}
}
CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFilesCount);
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->mibFilesCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
{
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFiles[i1].length);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibFiles[i1].length);
if (primitive->mibFiles[i1].length)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->mibFiles[i1].data, ((CsrUint16) (primitive->mibFiles[i1].length)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibFiles[i1].data, ((u16) (primitive->mibFiles[i1].length)));
}
}
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->mibFilesCount, buffer, &offset);
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->mibFilesCount, buffer, &offset);
primitive->mibFiles = NULL;
if (primitive->mibFilesCount)
{
primitive->mibFiles = (CsrWifiSmeDataBlock *)CsrPmemAlloc(sizeof(CsrWifiSmeDataBlock) * primitive->mibFilesCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
{
- CsrUint16Des((CsrUint16 *) &primitive->mibFiles[i1].length, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibFiles[i1].length, buffer, &offset);
if (primitive->mibFiles[i1].length)
{
primitive->mibFiles[i1].data = (u8 *)CsrPmemAlloc(primitive->mibFiles[i1].length);
- CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((CsrUint16) (primitive->mibFiles[i1].length)));
+ CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((u16) (primitive->mibFiles[i1].length)));
}
else
{
{
CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *) voidPrimitivePointer;
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
{
CsrPmemFree(primitive->mibFiles[i1].data);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
bufferSize += 6; /* u8 primitive->address.a[6] */
- bufferSize += 2; /* CsrUint16 primitive->mibFilesCount */
+ bufferSize += 2; /* u16 primitive->mibFilesCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
{
- bufferSize += 2; /* CsrUint16 primitive->mibFiles[i1].length */
+ bufferSize += 2; /* u16 primitive->mibFiles[i1].length */
bufferSize += primitive->mibFiles[i1].length; /* u8 primitive->mibFiles[i1].data */
}
}
CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFilesCount);
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->mibFilesCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
{
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFiles[i1].length);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibFiles[i1].length);
if (primitive->mibFiles[i1].length)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->mibFiles[i1].data, ((CsrUint16) (primitive->mibFiles[i1].length)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibFiles[i1].data, ((u16) (primitive->mibFiles[i1].length)));
}
}
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->mibFilesCount, buffer, &offset);
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->mibFilesCount, buffer, &offset);
primitive->mibFiles = NULL;
if (primitive->mibFilesCount)
{
primitive->mibFiles = (CsrWifiSmeDataBlock *)CsrPmemAlloc(sizeof(CsrWifiSmeDataBlock) * primitive->mibFilesCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
{
- CsrUint16Des((CsrUint16 *) &primitive->mibFiles[i1].length, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibFiles[i1].length, buffer, &offset);
if (primitive->mibFiles[i1].length)
{
primitive->mibFiles[i1].data = (u8 *)CsrPmemAlloc(primitive->mibFiles[i1].length);
- CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((CsrUint16) (primitive->mibFiles[i1].length)));
+ CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((u16) (primitive->mibFiles[i1].length)));
}
else
{
{
CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *) voidPrimitivePointer;
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
{
CsrPmemFree(primitive->mibFiles[i1].data);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 37) */
bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsidsCount */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
bufferSize += 32; /* u8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsidsCount);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsids[i2].length);
}
}
primitive->cloakedSsids.cloakedSsids = (CsrWifiSsid *)CsrPmemAlloc(sizeof(CsrWifiSsid) * primitive->cloakedSsids.cloakedSsidsCount);
}
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
- CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
}
}
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.trustLevel);
- CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((CsrUint16) (2)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((u16) (2)));
CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.firmwareDriverInterface);
CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.enableStrictDraftN);
return(ptr);
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint8Des((u8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
- CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((CsrUint16) (2)));
+ CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((u16) (2)));
CsrUint8Des((u8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
CsrUint8Des((u8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
bufferSize += 8; /* u8 primitive->wpsConfig.primDeviceType.deviceDetails[8] */
bufferSize += 1; /* u8 primitive->wpsConfig.secondaryDeviceTypeCount */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
{
bufferSize += 8; /* u8 primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails[8] */
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.wpsVersion);
- CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.uuid, ((CsrUint16) (16)));
- CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.deviceName, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.uuid, ((u16) (16)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.deviceName, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.deviceNameLength);
- CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.manufacturer, ((CsrUint16) (64)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.manufacturer, ((u16) (64)));
CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.manufacturerLength);
- CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelName, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelName, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.modelNameLength);
- CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelNumber, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelNumber, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.modelNumberLength);
- CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.serialNumber, ((CsrUint16) (32)));
- CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.serialNumber, ((u16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.primDeviceType.deviceDetails, ((u16) (8)));
CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.secondaryDeviceTypeCount);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails, ((u16) (8)));
}
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->wpsConfig.configMethods);
+ CsrUint16Ser(ptr, len, (u16) primitive->wpsConfig.configMethods);
CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.rfBands);
- CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.osVersion, ((CsrUint16) (4)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.osVersion, ((u16) (4)));
return(ptr);
}
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint8Des((u8 *) &primitive->wpsConfig.wpsVersion, buffer, &offset);
- CsrMemCpyDes(primitive->wpsConfig.uuid, buffer, &offset, ((CsrUint16) (16)));
- CsrMemCpyDes(primitive->wpsConfig.deviceName, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->wpsConfig.uuid, buffer, &offset, ((u16) (16)));
+ CsrMemCpyDes(primitive->wpsConfig.deviceName, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->wpsConfig.deviceNameLength, buffer, &offset);
- CsrMemCpyDes(primitive->wpsConfig.manufacturer, buffer, &offset, ((CsrUint16) (64)));
+ CsrMemCpyDes(primitive->wpsConfig.manufacturer, buffer, &offset, ((u16) (64)));
CsrUint8Des((u8 *) &primitive->wpsConfig.manufacturerLength, buffer, &offset);
- CsrMemCpyDes(primitive->wpsConfig.modelName, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->wpsConfig.modelName, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->wpsConfig.modelNameLength, buffer, &offset);
- CsrMemCpyDes(primitive->wpsConfig.modelNumber, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->wpsConfig.modelNumber, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->wpsConfig.modelNumberLength, buffer, &offset);
- CsrMemCpyDes(primitive->wpsConfig.serialNumber, buffer, &offset, ((CsrUint16) (32)));
- CsrMemCpyDes(primitive->wpsConfig.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->wpsConfig.serialNumber, buffer, &offset, ((u16) (32)));
+ CsrMemCpyDes(primitive->wpsConfig.primDeviceType.deviceDetails, buffer, &offset, ((u16) (8)));
CsrUint8Des((u8 *) &primitive->wpsConfig.secondaryDeviceTypeCount, buffer, &offset);
primitive->wpsConfig.secondaryDeviceType = NULL;
if (primitive->wpsConfig.secondaryDeviceTypeCount)
primitive->wpsConfig.secondaryDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->wpsConfig.secondaryDeviceTypeCount);
}
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
{
- CsrMemCpyDes(primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails, buffer, &offset, ((u16) (8)));
}
}
- CsrUint16Des((CsrUint16 *) &primitive->wpsConfig.configMethods, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->wpsConfig.configMethods, buffer, &offset);
CsrUint8Des((u8 *) &primitive->wpsConfig.rfBands, buffer, &offset);
- CsrMemCpyDes(primitive->wpsConfig.osVersion, buffer, &offset, ((CsrUint16) (4)));
+ CsrMemCpyDes(primitive->wpsConfig.osVersion, buffer, &offset, ((u16) (4)));
return primitive;
}
CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
if (primitive->dataLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
}
return(ptr);
}
if (primitive->dataLength)
{
primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
- CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
}
else
{
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 2; /* CsrUint16 primitive->adHocConfig.atimWindowTu */
- bufferSize += 2; /* CsrUint16 primitive->adHocConfig.beaconPeriodTu */
- bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinOnlyAttempts */
- bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinAttemptIntervalMs */
+ bufferSize += 2; /* u16 primitive->adHocConfig.atimWindowTu */
+ bufferSize += 2; /* u16 primitive->adHocConfig.beaconPeriodTu */
+ bufferSize += 2; /* u16 primitive->adHocConfig.joinOnlyAttempts */
+ bufferSize += 2; /* u16 primitive->adHocConfig.joinAttemptIntervalMs */
return bufferSize;
}
CsrWifiSmeAdhocConfigGetCfm *primitive = (CsrWifiSmeAdhocConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.atimWindowTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.beaconPeriodTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinOnlyAttempts);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinAttemptIntervalMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.atimWindowTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.beaconPeriodTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.joinOnlyAttempts);
+ CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.joinAttemptIntervalMs);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.atimWindowTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.beaconPeriodTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinOnlyAttempts, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinAttemptIntervalMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->adHocConfig.atimWindowTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->adHocConfig.beaconPeriodTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->adHocConfig.joinOnlyAttempts, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->adHocConfig.joinAttemptIntervalMs, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 98) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 32; /* u8 primitive->connectionInfo.ssid.ssid[32] */
bufferSize += 1; /* u8 primitive->connectionInfo.ssid.length */
bufferSize += 6; /* u8 primitive->connectionInfo.bssid.a[6] */
bufferSize += 1; /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
bufferSize += 1; /* u8 primitive->connectionInfo.channelNumber */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.channelFrequency */
+ bufferSize += 2; /* u16 primitive->connectionInfo.channelFrequency */
bufferSize += 2; /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.groupCipher */
bufferSize += 1; /* CsrWifiSmeRadioIF primitive->connectionInfo.ifIndex */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.atimWindowTu */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
+ bufferSize += 2; /* u16 primitive->connectionInfo.atimWindowTu */
+ bufferSize += 2; /* u16 primitive->connectionInfo.beaconPeriodTu */
bufferSize += 1; /* CsrBool primitive->connectionInfo.reassociation */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.beaconFrameLength */
bufferSize += primitive->connectionInfo.beaconFrameLength; /* u8 primitive->connectionInfo.beaconFrame */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.associationReqFrameLength */
bufferSize += primitive->connectionInfo.associationReqFrameLength; /* u8 primitive->connectionInfo.associationReqFrame */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.associationRspFrameLength */
bufferSize += primitive->connectionInfo.associationRspFrameLength; /* u8 primitive->connectionInfo.associationRspFrame */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocScanInfoElementsLength */
bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocReqCapabilities */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocReqListenIntervalTu */
bufferSize += 6; /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocReqInfoElementsLength */
bufferSize += primitive->connectionInfo.assocReqInfoElementsLength; /* u8 primitive->connectionInfo.assocReqInfoElements */
bufferSize += 2; /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocRspCapabilityInfo */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocRspAssociationId */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocRspInfoElementsLength */
bufferSize += primitive->connectionInfo.assocRspInfoElementsLength; /* u8 primitive->connectionInfo.assocRspInfoElements */
bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->deauthReason */
return bufferSize;
CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.networkType80211);
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.channelNumber);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.channelFrequency);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.authMode);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.pairwiseCipher);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.groupCipher);
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.atimWindowTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconPeriodTu);
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconFrameLength);
if (primitive->connectionInfo.beaconFrameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((u16) (primitive->connectionInfo.beaconFrameLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationReqFrameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationReqFrameLength);
if (primitive->connectionInfo.associationReqFrameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationRspFrameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationRspFrameLength);
if (primitive->connectionInfo.associationRspFrameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocScanInfoElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocScanInfoElementsLength);
if (primitive->connectionInfo.assocScanInfoElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqCapabilities);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqListenIntervalTu);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqInfoElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqCapabilities);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqListenIntervalTu);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqInfoElementsLength);
if (primitive->connectionInfo.assocReqInfoElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspResult);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspCapabilityInfo);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspAssociationId);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspInfoElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspResult);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspCapabilityInfo);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspAssociationId);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspInfoElementsLength);
if (primitive->connectionInfo.assocRspInfoElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->deauthReason);
+ CsrUint16Ser(ptr, len, (u16) primitive->deauthReason);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
- CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.authMode, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
if (primitive->connectionInfo.beaconFrameLength)
{
primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
- CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((u16) (primitive->connectionInfo.beaconFrameLength)));
}
else
{
primitive->connectionInfo.beaconFrame = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationReqFrameLength)
{
primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
- CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
}
else
{
primitive->connectionInfo.associationReqFrame = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationRspFrameLength)
{
primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
- CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
}
else
{
primitive->connectionInfo.associationRspFrame = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocScanInfoElementsLength)
{
primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
- CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
}
else
{
primitive->connectionInfo.assocScanInfoElements = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
- CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocReqInfoElementsLength)
{
primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
- CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
}
else
{
primitive->connectionInfo.assocReqInfoElements = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocRspInfoElementsLength)
{
primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
- CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
}
else
{
primitive->connectionInfo.assocRspInfoElements = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->deauthReason, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->deauthReason, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 44) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 6; /* u8 primitive->address.a[6] */
bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
bufferSize += 1; /* u8 primitive->ssid.length */
CsrWifiSmeAssociationStartInd *primitive = (CsrWifiSmeAssociationStartInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
- CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
- CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
+ CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
return primitive;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 1; /* u8 primitive->getAddressCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getAddressCount; i1++)
{
bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint8Ser(ptr, len, (u8) primitive->getAddressCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getAddressCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((u16) (6)));
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint8Des((u8 *) &primitive->getAddressCount, buffer, &offset);
primitive->getAddresses = NULL;
primitive->getAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->getAddressCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getAddressCount; i1++)
{
- CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((u16) (6)));
}
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 2; /* CsrUint16 primitive->calibrationDataLength */
+ bufferSize += 2; /* u16 primitive->calibrationDataLength */
bufferSize += primitive->calibrationDataLength; /* u8 primitive->calibrationData */
return bufferSize;
}
CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->calibrationDataLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->calibrationDataLength);
if (primitive->calibrationDataLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->calibrationData, ((CsrUint16) (primitive->calibrationDataLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->calibrationData, ((u16) (primitive->calibrationDataLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->calibrationDataLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->calibrationDataLength, buffer, &offset);
if (primitive->calibrationDataLength)
{
primitive->calibrationData = (u8 *)CsrPmemAlloc(primitive->calibrationDataLength);
- CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((CsrUint16) (primitive->calibrationDataLength)));
+ CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((u16) (primitive->calibrationDataLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* u8 primitive->ccxConfig.keepAliveTimeMs */
bufferSize += 1; /* CsrBool primitive->ccxConfig.apRoamingEnabled */
CsrWifiSmeCcxConfigGetCfm *primitive = (CsrWifiSmeCcxConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.keepAliveTimeMs);
CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.apRoamingEnabled);
CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.measurementsMask);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
CsrUint8Des((u8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
CsrUint8Des((u8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiSmeCcxConfigSetCfm *primitive = (CsrWifiSmeCcxConfigSetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrBool primitive->coexConfig.coexEnableSchemeManagement */
bufferSize += 1; /* CsrBool primitive->coexConfig.coexPeriodicWakeHost */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficBurstyLatencyMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficContinuousLatencyMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutDurationMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutPeriodMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutDurationMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutPeriodMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutDurationMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutDurationMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutPeriodMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutDurationMs */
- bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexTrafficBurstyLatencyMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexTrafficContinuousLatencyMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexObexBlackoutDurationMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexObexBlackoutPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpBrBlackoutDurationMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpBrBlackoutPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpEdrBlackoutDurationMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexPagingBlackoutDurationMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexPagingBlackoutPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexInquiryBlackoutDurationMs */
+ bufferSize += 2; /* u16 primitive->coexConfig.coexInquiryBlackoutPeriodMs */
return bufferSize;
}
CsrWifiSmeCoexConfigGetCfm *primitive = (CsrWifiSmeCoexConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexEnableSchemeManagement);
CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexPeriodicWakeHost);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutDurationMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutPeriodMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutDurationMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutPeriodMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutDurationMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutDurationMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutPeriodMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutDurationMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexObexBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexObexBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpBrBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpBrBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpEdrBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexPagingBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexPagingBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexInquiryBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexInquiryBlackoutPeriodMs);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
CsrUint8Des((u8 *) &primitive->coexConfig.coexPeriodicWakeHost, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutPeriodMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutDurationMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutPeriodMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutDurationMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutDurationMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutPeriodMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutDurationMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexObexBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpBrBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpBrBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpEdrBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexPagingBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexPagingBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexInquiryBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexConfig.coexInquiryBlackoutPeriodMs, buffer, &offset);
return primitive;
}
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrBool primitive->coexInfo.hasTrafficData */
bufferSize += 1; /* CsrWifiSmeTrafficType primitive->coexInfo.currentTrafficType */
- bufferSize += 2; /* CsrUint16 primitive->coexInfo.currentPeriodMs */
+ bufferSize += 2; /* u16 primitive->coexInfo.currentPeriodMs */
bufferSize += 1; /* CsrWifiSmePowerSaveLevel primitive->coexInfo.currentPowerSave */
- bufferSize += 2; /* CsrUint16 primitive->coexInfo.currentCoexPeriodMs */
- bufferSize += 2; /* CsrUint16 primitive->coexInfo.currentCoexLatencyMs */
+ 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 */
CsrWifiSmeCoexInfoGetCfm *primitive = (CsrWifiSmeCoexInfoGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.hasTrafficData);
CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentTrafficType);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->coexInfo.currentPeriodMs);
CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentPowerSave);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentCoexPeriodMs);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentCoexLatencyMs);
+ 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);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->coexInfo.hasTrafficData, buffer, &offset);
CsrUint8Des((u8 *) &primitive->coexInfo.currentTrafficType, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->coexInfo.currentPeriodMs, buffer, &offset);
CsrUint8Des((u8 *) &primitive->coexInfo.currentPowerSave, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentCoexPeriodMs, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentCoexLatencyMs, buffer, &offset);
+ 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);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiSmeConnectCfm *primitive = (CsrWifiSmeConnectCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 59) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 32; /* u8 primitive->connectionConfig.ssid.ssid[32] */
bufferSize += 1; /* u8 primitive->connectionConfig.ssid.length */
bufferSize += 1; /* CsrWifiSme80211PrivacyMode primitive->connectionConfig.privacyMode */
bufferSize += 2; /* CsrWifiSmeAuthModeMask primitive->connectionConfig.authModeMask */
bufferSize += 2; /* CsrWifiSmeEncryptionMask primitive->connectionConfig.encryptionModeMask */
- bufferSize += 2; /* CsrUint16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* u8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
bufferSize += 1; /* CsrWifiSmeWmmQosInfoMask primitive->connectionConfig.wmmQosInfo */
bufferSize += 1; /* CsrBool primitive->connectionConfig.adhocJoinOnly */
CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((CsrUint16) (32)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ssid.length);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.bssType);
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ifIndex);
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.privacyMode);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.authModeMask);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.encryptionModeMask);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.authModeMask);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.encryptionModeMask);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((u16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
}
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.wmmQosInfo);
CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocJoinOnly);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
- CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->connectionConfig.bssType, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
{
primitive->connectionConfig.mlmeAssociateReqInformationElements = (u8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
- CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+ CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((u16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 96) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 32; /* u8 primitive->connectionInfo.ssid.ssid[32] */
bufferSize += 1; /* u8 primitive->connectionInfo.ssid.length */
bufferSize += 6; /* u8 primitive->connectionInfo.bssid.a[6] */
bufferSize += 1; /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
bufferSize += 1; /* u8 primitive->connectionInfo.channelNumber */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.channelFrequency */
+ bufferSize += 2; /* u16 primitive->connectionInfo.channelFrequency */
bufferSize += 2; /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.groupCipher */
bufferSize += 1; /* CsrWifiSmeRadioIF primitive->connectionInfo.ifIndex */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.atimWindowTu */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
+ bufferSize += 2; /* u16 primitive->connectionInfo.atimWindowTu */
+ bufferSize += 2; /* u16 primitive->connectionInfo.beaconPeriodTu */
bufferSize += 1; /* CsrBool primitive->connectionInfo.reassociation */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.beaconFrameLength */
bufferSize += primitive->connectionInfo.beaconFrameLength; /* u8 primitive->connectionInfo.beaconFrame */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.associationReqFrameLength */
bufferSize += primitive->connectionInfo.associationReqFrameLength; /* u8 primitive->connectionInfo.associationReqFrame */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.associationRspFrameLength */
bufferSize += primitive->connectionInfo.associationRspFrameLength; /* u8 primitive->connectionInfo.associationRspFrame */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocScanInfoElementsLength */
bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocReqCapabilities */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocReqListenIntervalTu */
bufferSize += 6; /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocReqInfoElementsLength */
bufferSize += primitive->connectionInfo.assocReqInfoElementsLength; /* u8 primitive->connectionInfo.assocReqInfoElements */
bufferSize += 2; /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocRspCapabilityInfo */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocRspAssociationId */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocRspInfoElementsLength */
bufferSize += primitive->connectionInfo.assocRspInfoElementsLength; /* u8 primitive->connectionInfo.assocRspInfoElements */
return bufferSize;
}
CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.networkType80211);
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.channelNumber);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.channelFrequency);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.authMode);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.pairwiseCipher);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.groupCipher);
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.atimWindowTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconPeriodTu);
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconFrameLength);
if (primitive->connectionInfo.beaconFrameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((u16) (primitive->connectionInfo.beaconFrameLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationReqFrameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationReqFrameLength);
if (primitive->connectionInfo.associationReqFrameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationRspFrameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationRspFrameLength);
if (primitive->connectionInfo.associationRspFrameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocScanInfoElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocScanInfoElementsLength);
if (primitive->connectionInfo.assocScanInfoElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqCapabilities);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqListenIntervalTu);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqInfoElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqCapabilities);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqListenIntervalTu);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqInfoElementsLength);
if (primitive->connectionInfo.assocReqInfoElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspResult);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspCapabilityInfo);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspAssociationId);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspInfoElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspResult);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspCapabilityInfo);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspAssociationId);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspInfoElementsLength);
if (primitive->connectionInfo.assocRspInfoElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
- CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.authMode, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
if (primitive->connectionInfo.beaconFrameLength)
{
primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
- CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((u16) (primitive->connectionInfo.beaconFrameLength)));
}
else
{
primitive->connectionInfo.beaconFrame = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationReqFrameLength)
{
primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
- CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
}
else
{
primitive->connectionInfo.associationReqFrame = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationRspFrameLength)
{
primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
- CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
}
else
{
primitive->connectionInfo.associationRspFrame = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocScanInfoElementsLength)
{
primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
- CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
}
else
{
primitive->connectionInfo.assocScanInfoElements = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
- CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocReqInfoElementsLength)
{
primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
- CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
}
else
{
primitive->connectionInfo.assocReqInfoElements = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocRspInfoElementsLength)
{
primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
- CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiRssi */
bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiSnr */
return bufferSize;
CsrWifiSmeConnectionQualityInd *primitive = (CsrWifiSmeConnectionQualityInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiRssi);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiSnr);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->linkQuality.unifiRssi);
+ CsrUint16Ser(ptr, len, (u16) primitive->linkQuality.unifiSnr);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiRssi, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiSnr, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->linkQuality.unifiRssi, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->linkQuality.unifiSnr, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 101) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* u8 primitive->connectionStats.unifiTxDataRate */
bufferSize += 1; /* u8 primitive->connectionStats.unifiRxDataRate */
CsrWifiSmeConnectionStatsGetCfm *primitive = (CsrWifiSmeConnectionStatsGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ 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);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ 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);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiSmeDisconnectCfm *primitive = (CsrWifiSmeDisconnectCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSmeHostPowerMode primitive->hostConfig.powerMode */
- bufferSize += 2; /* CsrUint16 primitive->hostConfig.applicationDataPeriodMs */
+ bufferSize += 2; /* u16 primitive->hostConfig.applicationDataPeriodMs */
return bufferSize;
}
CsrWifiSmeHostConfigGetCfm *primitive = (CsrWifiSmeHostConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->hostConfig.powerMode);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->hostConfig.applicationDataPeriodMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->hostConfig.applicationDataPeriodMs);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->hostConfig.powerMode, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiSmeHostConfigSetCfm *primitive = (CsrWifiSmeHostConfigSetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrWifiSmeIbssStationInd *primitive = (CsrWifiSmeIbssStationInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->isconnected);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->isconnected, buffer, &offset);
return primitive;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 1; /* CsrWifiSmeKeyType primitive->keyType */
CsrWifiSmeKeyCfm *primitive = (CsrWifiSmeKeyCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint8Ser(ptr, len, (u8) primitive->keyType);
- CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint8Des((u8 *) &primitive->keyType, buffer, &offset);
- CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiRssi */
bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiSnr */
CsrWifiSmeLinkQualityGetCfm *primitive = (CsrWifiSmeLinkQualityGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiRssi);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiSnr);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->linkQuality.unifiRssi);
+ CsrUint16Ser(ptr, len, (u16) primitive->linkQuality.unifiSnr);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiRssi, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiSnr, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->linkQuality.unifiRssi, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->linkQuality.unifiSnr, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 99) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeMediaStatus primitive->mediaStatus */
bufferSize += 32; /* u8 primitive->connectionInfo.ssid.ssid[32] */
bufferSize += 1; /* u8 primitive->connectionInfo.ssid.length */
bufferSize += 6; /* u8 primitive->connectionInfo.bssid.a[6] */
bufferSize += 1; /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
bufferSize += 1; /* u8 primitive->connectionInfo.channelNumber */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.channelFrequency */
+ bufferSize += 2; /* u16 primitive->connectionInfo.channelFrequency */
bufferSize += 2; /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.groupCipher */
bufferSize += 1; /* CsrWifiSmeRadioIF primitive->connectionInfo.ifIndex */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.atimWindowTu */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
+ bufferSize += 2; /* u16 primitive->connectionInfo.atimWindowTu */
+ bufferSize += 2; /* u16 primitive->connectionInfo.beaconPeriodTu */
bufferSize += 1; /* CsrBool primitive->connectionInfo.reassociation */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.beaconFrameLength */
bufferSize += primitive->connectionInfo.beaconFrameLength; /* u8 primitive->connectionInfo.beaconFrame */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.associationReqFrameLength */
bufferSize += primitive->connectionInfo.associationReqFrameLength; /* u8 primitive->connectionInfo.associationReqFrame */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.associationRspFrameLength */
bufferSize += primitive->connectionInfo.associationRspFrameLength; /* u8 primitive->connectionInfo.associationRspFrame */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocScanInfoElementsLength */
bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocReqCapabilities */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocReqListenIntervalTu */
bufferSize += 6; /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocReqInfoElementsLength */
bufferSize += primitive->connectionInfo.assocReqInfoElementsLength; /* u8 primitive->connectionInfo.assocReqInfoElements */
bufferSize += 2; /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
- bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocRspCapabilityInfo */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocRspAssociationId */
+ bufferSize += 2; /* u16 primitive->connectionInfo.assocRspInfoElementsLength */
bufferSize += primitive->connectionInfo.assocRspInfoElementsLength; /* u8 primitive->connectionInfo.assocRspInfoElements */
bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->disassocReason */
bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->deauthReason */
CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.networkType80211);
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.channelNumber);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.channelFrequency);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.authMode);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.pairwiseCipher);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.groupCipher);
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.atimWindowTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconPeriodTu);
CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconFrameLength);
if (primitive->connectionInfo.beaconFrameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((u16) (primitive->connectionInfo.beaconFrameLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationReqFrameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationReqFrameLength);
if (primitive->connectionInfo.associationReqFrameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationRspFrameLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationRspFrameLength);
if (primitive->connectionInfo.associationRspFrameLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocScanInfoElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocScanInfoElementsLength);
if (primitive->connectionInfo.assocScanInfoElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqCapabilities);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqListenIntervalTu);
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqInfoElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqCapabilities);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqListenIntervalTu);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqInfoElementsLength);
if (primitive->connectionInfo.assocReqInfoElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspResult);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspCapabilityInfo);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspAssociationId);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspInfoElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspResult);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspCapabilityInfo);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspAssociationId);
+ CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspInfoElementsLength);
if (primitive->connectionInfo.assocRspInfoElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
}
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->disassocReason);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->deauthReason);
+ CsrUint16Ser(ptr, len, (u16) primitive->disassocReason);
+ CsrUint16Ser(ptr, len, (u16) primitive->deauthReason);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
- CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
- CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.authMode, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
if (primitive->connectionInfo.beaconFrameLength)
{
primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
- CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((u16) (primitive->connectionInfo.beaconFrameLength)));
}
else
{
primitive->connectionInfo.beaconFrame = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationReqFrameLength)
{
primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
- CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
}
else
{
primitive->connectionInfo.associationReqFrame = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationRspFrameLength)
{
primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
- CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
}
else
{
primitive->connectionInfo.associationRspFrame = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocScanInfoElementsLength)
{
primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
- CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
}
else
{
primitive->connectionInfo.assocScanInfoElements = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
- CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocReqInfoElementsLength)
{
primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
- CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
}
else
{
primitive->connectionInfo.assocReqInfoElements = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocRspInfoElementsLength)
{
primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
- CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
}
else
{
primitive->connectionInfo.assocRspInfoElements = NULL;
}
- CsrUint16Des((CsrUint16 *) &primitive->disassocReason, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->deauthReason, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->disassocReason, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->deauthReason, buffer, &offset);
return primitive;
}
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrBool primitive->mibConfig.unifiFixMaxTxDataRate */
bufferSize += 1; /* u8 primitive->mibConfig.unifiFixTxDataRate */
- bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11RtsThreshold */
- bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11FragmentationThreshold */
- bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11CurrentTxPowerLevel */
+ bufferSize += 2; /* u16 primitive->mibConfig.dot11RtsThreshold */
+ bufferSize += 2; /* u16 primitive->mibConfig.dot11FragmentationThreshold */
+ bufferSize += 2; /* u16 primitive->mibConfig.dot11CurrentTxPowerLevel */
return bufferSize;
}
CsrWifiSmeMibConfigGetCfm *primitive = (CsrWifiSmeMibConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixMaxTxDataRate);
CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixTxDataRate);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11RtsThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11FragmentationThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11CurrentTxPowerLevel);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11RtsThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11FragmentationThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11CurrentTxPowerLevel);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixTxDataRate, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
+ bufferSize += 2; /* u16 primitive->mibAttributeLength */
bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
return bufferSize;
}
CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibAttributeLength);
if (primitive->mibAttributeLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((u16) (primitive->mibAttributeLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibAttributeLength, buffer, &offset);
if (primitive->mibAttributeLength)
{
primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
- CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+ CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((u16) (primitive->mibAttributeLength)));
}
else
{
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
+ bufferSize += 2; /* u16 primitive->mibAttributeLength */
bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
return bufferSize;
}
CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->mibAttributeLength);
if (primitive->mibAttributeLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((u16) (primitive->mibAttributeLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->mibAttributeLength, buffer, &offset);
if (primitive->mibAttributeLength)
{
primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
- CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+ CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((u16) (primitive->mibAttributeLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrBool primitive->secondFailure */
- bufferSize += 2; /* CsrUint16 primitive->count */
+ bufferSize += 2; /* u16 primitive->count */
bufferSize += 6; /* u8 primitive->address.a[6] */
bufferSize += 1; /* CsrWifiSmeKeyType primitive->keyType */
return bufferSize;
CsrWifiSmeMicFailureInd *primitive = (CsrWifiSmeMicFailureInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->secondFailure);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->count);
- CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->count);
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->keyType);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->secondFailure, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->count, buffer, &offset);
- CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->count, buffer, &offset);
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->keyType, buffer, &offset);
return primitive;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 1; /* u8 primitive->getAddressesCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
{
bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint8Ser(ptr, len, (u8) primitive->getAddressesCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((u16) (6)));
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint8Des((u8 *) &primitive->getAddressesCount, buffer, &offset);
primitive->getAddresses = NULL;
primitive->getAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->getAddressesCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
{
- CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((u16) (6)));
}
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiSmePacketFilterSetCfm *primitive = (CsrWifiSmePacketFilterSetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrWifiSmePermanentMacAddressGetCfm *primitive = (CsrWifiSmePermanentMacAddressGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrMemCpySer(ptr, len, (const void *) primitive->permanentMacAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->permanentMacAddress.a, ((u16) (6)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrMemCpyDes(primitive->permanentMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->permanentMacAddress.a, buffer, &offset, ((u16) (6)));
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* u8 primitive->pmkidCandidatesCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
{
bufferSize += 6; /* u8 primitive->pmkidCandidates[i1].bssid.a[6] */
CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->pmkidCandidatesCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->pmkidCandidates[i1].bssid.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->pmkidCandidates[i1].bssid.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->pmkidCandidates[i1].preAuthAllowed);
}
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->pmkidCandidatesCount, buffer, &offset);
primitive->pmkidCandidates = NULL;
if (primitive->pmkidCandidatesCount)
primitive->pmkidCandidates = (CsrWifiSmePmkidCandidate *)CsrPmemAlloc(sizeof(CsrWifiSmePmkidCandidate) * primitive->pmkidCandidatesCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
{
- CsrMemCpyDes(primitive->pmkidCandidates[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->pmkidCandidates[i1].bssid.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->pmkidCandidates[i1].preAuthAllowed, buffer, &offset);
}
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 31) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 1; /* u8 primitive->getPmkidsCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
{
bufferSize += 6; /* u8 primitive->getPmkids[i1].bssid.a[6] */
CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint8Ser(ptr, len, (u8) primitive->getPmkidsCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->getPmkids[i1].bssid.a, ((CsrUint16) (6)));
- CsrMemCpySer(ptr, len, (const void *) primitive->getPmkids[i1].pmkid, ((CsrUint16) (16)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->getPmkids[i1].bssid.a, ((u16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->getPmkids[i1].pmkid, ((u16) (16)));
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint8Des((u8 *) &primitive->getPmkidsCount, buffer, &offset);
primitive->getPmkids = NULL;
primitive->getPmkids = (CsrWifiSmePmkid *)CsrPmemAlloc(sizeof(CsrWifiSmePmkid) * primitive->getPmkidsCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
{
- CsrMemCpyDes(primitive->getPmkids[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrMemCpyDes(primitive->getPmkids[i1].pmkid, buffer, &offset, ((CsrUint16) (16)));
+ CsrMemCpyDes(primitive->getPmkids[i1].bssid.a, buffer, &offset, ((u16) (6)));
+ CsrMemCpyDes(primitive->getPmkids[i1].pmkid, buffer, &offset, ((u16) (16)));
}
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSmePowerSaveLevel primitive->powerConfig.powerSaveLevel */
- bufferSize += 2; /* CsrUint16 primitive->powerConfig.listenIntervalTu */
+ bufferSize += 2; /* u16 primitive->powerConfig.listenIntervalTu */
bufferSize += 1; /* CsrBool primitive->powerConfig.rxDtims */
bufferSize += 1; /* CsrWifiSmeD3AutoScanMode primitive->powerConfig.d3AutoScanMode */
bufferSize += 1; /* u8 primitive->powerConfig.clientTrafficWindow */
CsrWifiSmePowerConfigGetCfm *primitive = (CsrWifiSmePowerConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.powerSaveLevel);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->powerConfig.listenIntervalTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->powerConfig.listenIntervalTu);
CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.rxDtims);
CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.d3AutoScanMode);
CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.clientTrafficWindow);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
CsrUint8Des((u8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
CsrUint8Des((u8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
CsrUint8Des((u8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
CsrWifiSmeRegulatoryDomainInfoGetCfm *primitive = (CsrWifiSmeRegulatoryDomainInfoGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->regDomInfo.dot11MultiDomainCapabilityImplemented);
CsrUint8Ser(ptr, len, (u8) primitive->regDomInfo.dot11MultiDomainCapabilityEnabled);
CsrUint8Ser(ptr, len, (u8) primitive->regDomInfo.currentRegulatoryDomain);
- CsrMemCpySer(ptr, len, (const void *) primitive->regDomInfo.currentCountryCode, ((CsrUint16) (2)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->regDomInfo.currentCountryCode, ((u16) (2)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityImplemented, buffer, &offset);
CsrUint8Des((u8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityEnabled, buffer, &offset);
CsrUint8Des((u8 *) &primitive->regDomInfo.currentRegulatoryDomain, buffer, &offset);
- CsrMemCpyDes(primitive->regDomInfo.currentCountryCode, buffer, &offset, ((CsrUint16) (2)));
+ CsrMemCpyDes(primitive->regDomInfo.currentCountryCode, buffer, &offset, ((u16) (2)));
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiSmeRoamCompleteInd *primitive = (CsrWifiSmeRoamCompleteInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeRoamReason primitive->roamReason */
bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->reason80211 */
return bufferSize;
CsrWifiSmeRoamStartInd *primitive = (CsrWifiSmeRoamStartInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint8Ser(ptr, len, (u8) primitive->roamReason);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->reason80211);
+ CsrUint16Ser(ptr, len, (u16) primitive->reason80211);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint8Des((u8 *) &primitive->roamReason, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->reason80211, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->reason80211, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 72) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].rssiHighThreshold */
bufferSize += 1; /* CsrBool primitive->roamingConfig.disableSmoothRoaming */
bufferSize += 1; /* CsrBool primitive->roamingConfig.disableRoamScans */
bufferSize += 1; /* u8 primitive->roamingConfig.reconnectLimit */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.reconnectLimitIntervalMs */
+ bufferSize += 2; /* u16 primitive->roamingConfig.reconnectLimitIntervalMs */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].intervalSeconds */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].validitySeconds */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].intervalSeconds */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].validitySeconds */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu */
}
}
return bufferSize;
CsrWifiSmeRoamingConfigGetCfm *primitive = (CsrWifiSmeRoamingConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiHighThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiLowThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrHighThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].rssiHighThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].rssiLowThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].snrHighThreshold);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
}
}
CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableSmoothRoaming);
CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableRoamScans);
CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.reconnectLimit);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.reconnectLimitIntervalMs);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.reconnectLimitIntervalMs);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].intervalSeconds);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].validitySeconds);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].intervalSeconds);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].validitySeconds);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu);
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiHighThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiLowThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrHighThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].rssiHighThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].rssiLowThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].snrHighThreshold, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
}
}
CsrUint8Des((u8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
CsrUint8Des((u8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
CsrUint8Des((u8 *) &primitive->roamingConfig.reconnectLimit, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 3; i2++)
{
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].intervalSeconds, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].validitySeconds, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].intervalSeconds, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].validitySeconds, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
}
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiSmeRoamingConfigSetCfm *primitive = (CsrWifiSmeRoamingConfigSetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 65) */
bufferSize += 2; /* CsrResult primitive->status */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].intervalSeconds */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].validitySeconds */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].intervalSeconds */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].validitySeconds */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu */
+ bufferSize += 2; /* u16 primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu */
}
}
bufferSize += 1; /* CsrBool primitive->scanConfig.disableAutonomousScans */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.maxResults */
+ bufferSize += 2; /* u16 primitive->scanConfig.maxResults */
bufferSize += 1; /* s8 primitive->scanConfig.highRssiThreshold */
bufferSize += 1; /* s8 primitive->scanConfig.lowRssiThreshold */
bufferSize += 1; /* s8 primitive->scanConfig.deltaRssiThreshold */
bufferSize += 1; /* s8 primitive->scanConfig.highSnrThreshold */
bufferSize += 1; /* s8 primitive->scanConfig.lowSnrThreshold */
bufferSize += 1; /* s8 primitive->scanConfig.deltaSnrThreshold */
- bufferSize += 2; /* CsrUint16 primitive->scanConfig.passiveChannelListCount */
+ bufferSize += 2; /* u16 primitive->scanConfig.passiveChannelListCount */
bufferSize += primitive->scanConfig.passiveChannelListCount; /* u8 primitive->scanConfig.passiveChannelList */
return bufferSize;
}
CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].intervalSeconds);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].validitySeconds);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].intervalSeconds);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].validitySeconds);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
}
}
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.disableAutonomousScans);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.maxResults);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.maxResults);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highRssiThreshold);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowRssiThreshold);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaRssiThreshold);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highSnrThreshold);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowSnrThreshold);
CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaSnrThreshold);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.passiveChannelListCount);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.passiveChannelListCount);
if (primitive->scanConfig.passiveChannelListCount)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->scanConfig.passiveChannelList, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanConfig.passiveChannelList, ((u16) (primitive->scanConfig.passiveChannelListCount)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < 4; i2++)
{
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].intervalSeconds, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].validitySeconds, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].intervalSeconds, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].validitySeconds, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
}
}
CsrUint8Des((u8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.maxResults, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.maxResults, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanConfig.deltaSnrThreshold, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
if (primitive->scanConfig.passiveChannelListCount)
{
primitive->scanConfig.passiveChannelList = (u8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
- CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+ CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((u16) (primitive->scanConfig.passiveChannelListCount)));
}
else
{
bufferSize += 2; /* CsrInt16 primitive->result.rssi */
bufferSize += 2; /* CsrInt16 primitive->result.snr */
bufferSize += 1; /* CsrWifiSmeRadioIF primitive->result.ifIndex */
- bufferSize += 2; /* CsrUint16 primitive->result.beaconPeriodTu */
+ bufferSize += 2; /* u16 primitive->result.beaconPeriodTu */
bufferSize += 8; /* u8 primitive->result.timeStamp.data[8] */
bufferSize += 8; /* u8 primitive->result.localTime.data[8] */
- bufferSize += 2; /* CsrUint16 primitive->result.channelFrequency */
- bufferSize += 2; /* CsrUint16 primitive->result.capabilityInformation */
+ bufferSize += 2; /* u16 primitive->result.channelFrequency */
+ bufferSize += 2; /* u16 primitive->result.capabilityInformation */
bufferSize += 1; /* u8 primitive->result.channelNumber */
bufferSize += 1; /* CsrWifiSmeBasicUsability primitive->result.usability */
bufferSize += 1; /* CsrWifiSmeBssType primitive->result.bssType */
- bufferSize += 2; /* CsrUint16 primitive->result.informationElementsLength */
+ bufferSize += 2; /* u16 primitive->result.informationElementsLength */
bufferSize += primitive->result.informationElementsLength; /* u8 primitive->result.informationElements */
bufferSize += 1; /* CsrWifiSmeP2pRole primitive->result.p2pDeviceRole */
switch (primitive->result.p2pDeviceRole)
bufferSize += 6; /* u8 primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
bufferSize += 1; /* u8 primitive->result.deviceInfo.groupInfo.p2pClientInfoCount */
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
bufferSize += 6; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
bufferSize += 8; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
bufferSize += 1; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
{
- CsrUint16 i6;
+ u16 i6;
for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
{
bufferSize += 8; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
bufferSize += 8; /* u8 primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
bufferSize += 1; /* u8 primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
{
bufferSize += 8; /* u8 primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrMemCpySer(ptr, len, (const void *) primitive->result.ssid.ssid, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.ssid.ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->result.ssid.length);
- CsrMemCpySer(ptr, len, (const void *) primitive->result.bssid.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.rssi);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.snr);
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.bssid.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->result.rssi);
+ CsrUint16Ser(ptr, len, (u16) primitive->result.snr);
CsrUint8Ser(ptr, len, (u8) primitive->result.ifIndex);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.beaconPeriodTu);
- CsrMemCpySer(ptr, len, (const void *) primitive->result.timeStamp.data, ((CsrUint16) (8)));
- CsrMemCpySer(ptr, len, (const void *) primitive->result.localTime.data, ((CsrUint16) (8)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.channelFrequency);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.capabilityInformation);
+ CsrUint16Ser(ptr, len, (u16) primitive->result.beaconPeriodTu);
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.timeStamp.data, ((u16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.localTime.data, ((u16) (8)));
+ CsrUint16Ser(ptr, len, (u16) primitive->result.channelFrequency);
+ CsrUint16Ser(ptr, len, (u16) primitive->result.capabilityInformation);
CsrUint8Ser(ptr, len, (u8) primitive->result.channelNumber);
CsrUint8Ser(ptr, len, (u8) primitive->result.usability);
CsrUint8Ser(ptr, len, (u8) primitive->result.bssType);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.informationElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->result.informationElementsLength);
if (primitive->result.informationElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->result.informationElements, ((CsrUint16) (primitive->result.informationElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.informationElements, ((u16) (primitive->result.informationElementsLength)));
}
CsrUint8Ser(ptr, len, (u8) primitive->result.p2pDeviceRole);
switch (primitive->result.p2pDeviceRole)
break;
case CSR_WIFI_SME_P2P_ROLE_GO:
CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.groupCapability);
- CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2pClientInfoCount);
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((CsrUint16) (6)));
- CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((u16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
- CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((u16) (8)));
CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
{
- CsrUint16 i6;
+ u16 i6;
for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, ((u16) (8)));
}
}
- CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
}
}
CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.reservedNone.empty);
break;
case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
- CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.deviceInfo.standalonedevInfo.configMethods);
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->result.deviceInfo.standalonedevInfo.configMethods);
CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap);
- CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((u16) (8)));
CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, ((u16) (8)));
}
}
- CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceName, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceName, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.deviceNameLength);
break;
default:
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrMemCpyDes(primitive->result.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->result.ssid.ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->result.ssid.length, buffer, &offset);
- CsrMemCpyDes(primitive->result.bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->result.rssi, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->result.snr, buffer, &offset);
+ CsrMemCpyDes(primitive->result.bssid.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->result.rssi, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->result.snr, buffer, &offset);
CsrUint8Des((u8 *) &primitive->result.ifIndex, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->result.beaconPeriodTu, buffer, &offset);
- CsrMemCpyDes(primitive->result.timeStamp.data, buffer, &offset, ((CsrUint16) (8)));
- CsrMemCpyDes(primitive->result.localTime.data, buffer, &offset, ((CsrUint16) (8)));
- CsrUint16Des((CsrUint16 *) &primitive->result.channelFrequency, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->result.capabilityInformation, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->result.beaconPeriodTu, buffer, &offset);
+ CsrMemCpyDes(primitive->result.timeStamp.data, buffer, &offset, ((u16) (8)));
+ CsrMemCpyDes(primitive->result.localTime.data, buffer, &offset, ((u16) (8)));
+ CsrUint16Des((u16 *) &primitive->result.channelFrequency, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->result.capabilityInformation, buffer, &offset);
CsrUint8Des((u8 *) &primitive->result.channelNumber, buffer, &offset);
CsrUint8Des((u8 *) &primitive->result.usability, buffer, &offset);
CsrUint8Des((u8 *) &primitive->result.bssType, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->result.informationElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->result.informationElementsLength, buffer, &offset);
if (primitive->result.informationElementsLength)
{
primitive->result.informationElements = (u8 *)CsrPmemAlloc(primitive->result.informationElementsLength);
- CsrMemCpyDes(primitive->result.informationElements, buffer, &offset, ((CsrUint16) (primitive->result.informationElementsLength)));
+ CsrMemCpyDes(primitive->result.informationElements, buffer, &offset, ((u16) (primitive->result.informationElementsLength)));
}
else
{
break;
case CSR_WIFI_SME_P2P_ROLE_GO:
CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.groupCapability, buffer, &offset);
- CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
primitive->result.deviceInfo.groupInfo.p2PClientInfo = NULL;
if (primitive->result.deviceInfo.groupInfo.p2pClientInfoCount)
primitive->result.deviceInfo.groupInfo.p2PClientInfo = (CsrWifiSmeP2pClientInfoType *)CsrPmemAlloc(sizeof(CsrWifiSmeP2pClientInfoType) * primitive->result.deviceInfo.groupInfo.p2pClientInfoCount);
}
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
- CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((u16) (6)));
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, buffer, &offset);
- CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((u16) (8)));
CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = NULL;
if (primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount)
primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
}
{
- CsrUint16 i6;
+ u16 i6;
for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
{
- CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, buffer, &offset, ((u16) (8)));
}
}
- CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
}
}
CsrUint8Des((u8 *) &primitive->result.deviceInfo.reservedNone.empty, buffer, &offset);
break;
case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
- CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->result.deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
+ CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->result.deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
- CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((u16) (8)));
CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
primitive->result.deviceInfo.standalonedevInfo.secDeviceType = NULL;
if (primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount)
primitive->result.deviceInfo.standalonedevInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
}
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
{
- CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, buffer, &offset, ((u16) (8)));
}
}
- CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
break;
default:
{
case CSR_WIFI_SME_P2P_ROLE_GO:
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
CsrPmemFree(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 153) */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 2; /* CsrUint16 primitive->scanResultsCount */
+ bufferSize += 2; /* u16 primitive->scanResultsCount */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
{
bufferSize += 32; /* u8 primitive->scanResults[i1].ssid.ssid[32] */
bufferSize += 2; /* CsrInt16 primitive->scanResults[i1].rssi */
bufferSize += 2; /* CsrInt16 primitive->scanResults[i1].snr */
bufferSize += 1; /* CsrWifiSmeRadioIF primitive->scanResults[i1].ifIndex */
- bufferSize += 2; /* CsrUint16 primitive->scanResults[i1].beaconPeriodTu */
+ bufferSize += 2; /* u16 primitive->scanResults[i1].beaconPeriodTu */
bufferSize += 8; /* u8 primitive->scanResults[i1].timeStamp.data[8] */
bufferSize += 8; /* u8 primitive->scanResults[i1].localTime.data[8] */
- bufferSize += 2; /* CsrUint16 primitive->scanResults[i1].channelFrequency */
- bufferSize += 2; /* CsrUint16 primitive->scanResults[i1].capabilityInformation */
+ bufferSize += 2; /* u16 primitive->scanResults[i1].channelFrequency */
+ bufferSize += 2; /* u16 primitive->scanResults[i1].capabilityInformation */
bufferSize += 1; /* u8 primitive->scanResults[i1].channelNumber */
bufferSize += 1; /* CsrWifiSmeBasicUsability primitive->scanResults[i1].usability */
bufferSize += 1; /* CsrWifiSmeBssType primitive->scanResults[i1].bssType */
- bufferSize += 2; /* CsrUint16 primitive->scanResults[i1].informationElementsLength */
+ bufferSize += 2; /* u16 primitive->scanResults[i1].informationElementsLength */
bufferSize += primitive->scanResults[i1].informationElementsLength; /* u8 primitive->scanResults[i1].informationElements */
bufferSize += 1; /* CsrWifiSmeP2pRole primitive->scanResults[i1].p2pDeviceRole */
switch (primitive->scanResults[i1].p2pDeviceRole)
bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount */
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
{
- CsrUint16 i6;
+ u16 i6;
for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
{
bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
{
bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResultsCount);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanResultsCount);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].ssid.ssid, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].ssid.ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].ssid.length);
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].bssid.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].rssi);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].snr);
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].bssid.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].rssi);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].snr);
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].ifIndex);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].beaconPeriodTu);
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].timeStamp.data, ((CsrUint16) (8)));
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].localTime.data, ((CsrUint16) (8)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].channelFrequency);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].capabilityInformation);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].beaconPeriodTu);
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].timeStamp.data, ((u16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].localTime.data, ((u16) (8)));
+ CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].channelFrequency);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].capabilityInformation);
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].channelNumber);
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].usability);
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].bssType);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].informationElementsLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].informationElementsLength);
if (primitive->scanResults[i1].informationElementsLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].informationElements, ((CsrUint16) (primitive->scanResults[i1].informationElementsLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].informationElements, ((u16) (primitive->scanResults[i1].informationElementsLength)));
}
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].p2pDeviceRole);
switch (primitive->scanResults[i1].p2pDeviceRole)
break;
case CSR_WIFI_SME_P2P_ROLE_GO:
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability);
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, ((u16) (6)));
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount);
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((CsrUint16) (6)));
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((u16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((u16) (8)));
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
{
- CsrUint16 i6;
+ u16 i6;
for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, ((u16) (8)));
}
}
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
}
}
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.reservedNone.empty);
break;
case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, ((CsrUint16) (6)));
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods);
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, ((u16) (6)));
+ CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods);
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap);
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((u16) (8)));
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, ((u16) (8)));
}
}
- CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength);
break;
default:
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanResultsCount, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanResultsCount, buffer, &offset);
primitive->scanResults = NULL;
if (primitive->scanResultsCount)
{
primitive->scanResults = (CsrWifiSmeScanResult *)CsrPmemAlloc(sizeof(CsrWifiSmeScanResult) * primitive->scanResultsCount);
}
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
{
- CsrMemCpyDes(primitive->scanResults[i1].ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->scanResults[i1].ssid.ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->scanResults[i1].ssid.length, buffer, &offset);
- CsrMemCpyDes(primitive->scanResults[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].rssi, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].snr, buffer, &offset);
+ CsrMemCpyDes(primitive->scanResults[i1].bssid.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->scanResults[i1].rssi, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanResults[i1].snr, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanResults[i1].ifIndex, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].beaconPeriodTu, buffer, &offset);
- CsrMemCpyDes(primitive->scanResults[i1].timeStamp.data, buffer, &offset, ((CsrUint16) (8)));
- CsrMemCpyDes(primitive->scanResults[i1].localTime.data, buffer, &offset, ((CsrUint16) (8)));
- CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].channelFrequency, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].capabilityInformation, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanResults[i1].beaconPeriodTu, buffer, &offset);
+ CsrMemCpyDes(primitive->scanResults[i1].timeStamp.data, buffer, &offset, ((u16) (8)));
+ CsrMemCpyDes(primitive->scanResults[i1].localTime.data, buffer, &offset, ((u16) (8)));
+ CsrUint16Des((u16 *) &primitive->scanResults[i1].channelFrequency, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanResults[i1].capabilityInformation, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanResults[i1].channelNumber, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanResults[i1].usability, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanResults[i1].bssType, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].informationElementsLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->scanResults[i1].informationElementsLength, buffer, &offset);
if (primitive->scanResults[i1].informationElementsLength)
{
primitive->scanResults[i1].informationElements = (u8 *)CsrPmemAlloc(primitive->scanResults[i1].informationElementsLength);
- CsrMemCpyDes(primitive->scanResults[i1].informationElements, buffer, &offset, ((CsrUint16) (primitive->scanResults[i1].informationElementsLength)));
+ CsrMemCpyDes(primitive->scanResults[i1].informationElements, buffer, &offset, ((u16) (primitive->scanResults[i1].informationElementsLength)));
}
else
{
break;
case CSR_WIFI_SME_P2P_ROLE_GO:
CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability, buffer, &offset);
- CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((u16) (6)));
CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo = NULL;
if (primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount)
primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo = (CsrWifiSmeP2pClientInfoType *)CsrPmemAlloc(sizeof(CsrWifiSmeP2pClientInfoType) * primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount);
}
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
- CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((u16) (6)));
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, buffer, &offset);
- CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((u16) (8)));
CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = NULL;
if (primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount)
primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
}
{
- CsrUint16 i6;
+ u16 i6;
for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
{
- CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, buffer, &offset, ((u16) (8)));
}
}
- CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
}
}
CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.reservedNone.empty, buffer, &offset);
break;
case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
- CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((u16) (6)));
+ CsrUint16Des((u16 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
- CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((u16) (8)));
CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType = NULL;
if (primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount)
primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
}
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
{
- CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, buffer, &offset, ((u16) (8)));
}
}
- CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
break;
default:
{
CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *) voidPrimitivePointer;
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
{
CsrPmemFree(primitive->scanResults[i1].informationElements);
{
case CSR_WIFI_SME_P2P_ROLE_GO:
{
- CsrUint16 i4;
+ u16 i4;
for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
CsrPmemFree(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* u8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
bufferSize += 1; /* u8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
CsrWifiSmeSmeStaConfigGetCfm *primitive = (CsrWifiSmeSmeStaConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.wmmModeMask);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
CsrUint8Des((u8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
CsrWifiSmeSmeStaConfigSetCfm *primitive = (CsrWifiSmeSmeStaConfigSetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
bufferSize += 2; /* CsrResult primitive->status */
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 2; i1++)
{
bufferSize += 6; /* u8 primitive->stationMacAddress[i1].a[6] */
CsrWifiSmeStationMacAddressGetCfm *primitive = (CsrWifiSmeStationMacAddressGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 2; i1++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((u16) (6)));
}
}
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
{
- CsrUint16 i1;
+ u16 i1;
for (i1 = 0; i1 < 2; i1++)
{
- CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((u16) (6)));
}
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 4; /* CsrUint32 primitive->transactionId */
bufferSize += 1; /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
- bufferSize += 2; /* CsrUint16 primitive->tspecLength */
+ bufferSize += 2; /* u16 primitive->tspecLength */
bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
return bufferSize;
}
CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
CsrUint8Ser(ptr, len, (u8) primitive->tspecResultCode);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->tspecLength);
if (primitive->tspecLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((CsrUint16) (primitive->tspecLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((u16) (primitive->tspecLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
CsrUint8Des((u8 *) &primitive->tspecResultCode, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->tspecLength, buffer, &offset);
if (primitive->tspecLength)
{
primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
- CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
+ CsrMemCpyDes(primitive->tspec, buffer, &offset, ((u16) (primitive->tspecLength)));
}
else
{
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
- bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* u16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 4; /* CsrUint32 primitive->transactionId */
bufferSize += 1; /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
- bufferSize += 2; /* CsrUint16 primitive->tspecLength */
+ bufferSize += 2; /* u16 primitive->tspecLength */
bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
return bufferSize;
}
CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
CsrUint8Ser(ptr, len, (u8) primitive->tspecResultCode);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
+ CsrUint16Ser(ptr, len, (u16) primitive->tspecLength);
if (primitive->tspecLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((CsrUint16) (primitive->tspecLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((u16) (primitive->tspecLength)));
}
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
CsrUint8Des((u8 *) &primitive->tspecResultCode, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->tspecLength, buffer, &offset);
if (primitive->tspecLength)
{
primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
- CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
+ CsrMemCpyDes(primitive->tspec, buffer, &offset, ((u16) (primitive->tspecLength)));
}
else
{
CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ 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);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, 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);
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsidsCount */
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
bufferSize += 32; /* u8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsidsCount);
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((u16) (32)));
CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsids[i2].length);
}
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
primitive->cloakedSsids.cloakedSsids = NULL;
if (primitive->cloakedSsids.cloakedSsidsCount)
primitive->cloakedSsids.cloakedSsids = (CsrWifiSsid *)CsrPmemAlloc(sizeof(CsrWifiSsid) * primitive->cloakedSsids.cloakedSsidsCount);
}
{
- CsrUint16 i2;
+ u16 i2;
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
- CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((u16) (32)));
CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
}
}
CsrWifiSmeWifiOnInd *primitive = (CsrWifiSmeWifiOnInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
return primitive;
}
CsrWifiSmeSmeCommonConfigGetCfm *primitive = (CsrWifiSmeSmeCommonConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.trustLevel);
- CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((CsrUint16) (2)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((u16) (2)));
CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.firmwareDriverInterface);
CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.enableStrictDraftN);
return(ptr);
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
CsrUint8Des((u8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
- CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((CsrUint16) (2)));
+ CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((u16) (2)));
CsrUint8Des((u8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
CsrUint8Des((u8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 2; /* CsrUint16 primitive->numInterfaces */
+ bufferSize += 2; /* u16 primitive->numInterfaces */
bufferSize += 2; /* u8 primitive->capBitmap[2] */
return bufferSize;
}
CsrWifiSmeInterfaceCapabilityGetCfm *primitive = (CsrWifiSmeInterfaceCapabilityGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint16Ser(ptr, len, (CsrUint16) primitive->numInterfaces);
- CsrMemCpySer(ptr, len, (const void *) primitive->capBitmap, ((CsrUint16) (2)));
+ CsrUint16Ser(ptr, len, (u16) primitive->status);
+ CsrUint16Ser(ptr, len, (u16) primitive->numInterfaces);
+ CsrMemCpySer(ptr, len, (const void *) primitive->capBitmap, ((u16) (2)));
return(ptr);
}
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint16Des((CsrUint16 *) &primitive->numInterfaces, buffer, &offset);
- CsrMemCpyDes(primitive->capBitmap, buffer, &offset, ((CsrUint16) (2)));
+ CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((u16 *) &primitive->numInterfaces, buffer, &offset);
+ CsrMemCpyDes(primitive->capBitmap, buffer, &offset, ((u16) (2)));
return primitive;
}
CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
if (primitive->dataLength)
{
- CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
}
return(ptr);
}
if (primitive->dataLength)
{
primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
- CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
}
else
{
/* Common macros for NME and SME to be used temporarily until SoftMAC changes are made */
#define CSR_WIFI_NUM_INTERFACES (u8)0x1
-#define CSR_WIFI_INTERFACE_IN_USE (CsrUint16)0x0
+#define CSR_WIFI_INTERFACE_IN_USE (u16)0x0
/* This is used at places where interface Id isn't available*/
#define CSR_WIFI_INTERFACE_ZERO 0
/* Extract the Interface Id from the event */
#define CsrWifiVifUtilsGetVifTagFromEvent(msg) \
- ((CsrUint16) * ((CsrUint16 *) ((u8 *) (msg) + sizeof(CsrWifiFsmEvent))))
+ ((u16) * ((u16 *) ((u8 *) (msg) + sizeof(CsrWifiFsmEvent))))
/* The HPI Vif combines the type and the interface id */
#define CsrWifiVifUtilsGetVifTagFromHipEvent(msg) \
((msg)->virtualInterfaceIdentifier & 0x00FF)
#define CsrWifiVifUtilsPackHipEventVif(type, interfaceId) \
- ((CsrUint16)((interfaceId) | ((type) << 8)))
+ ((u16)((interfaceId) | ((type) << 8)))
/* TYPES DEFINITIONS ********************************************************/
*
* @param[in] u8 : interface capability bitmap
* @param[in] u8* : pointer to the array of current interface modes
- * @param[in] CsrUint16 : interfaceTag
+ * @param[in] u16 : interfaceTag
* @param[in] CsrWifiInterfaceMode : mode
*
* @return
*/
extern CsrBool CsrWifiVifUtilsCheckCompatibility(u8 interfaceCapability,
u8 *currentInterfaceModes,
- CsrUint16 interfaceTag,
+ u16 interfaceTag,
CsrWifiInterfaceMode mode);
/**
* NOTE: Only checks that the interface is supported, no checks are made to
* determine whether a supported interface may be made active.
*
- * @param[in] CsrUint16 : interfaceTag
+ * @param[in] u16 : interfaceTag
*
* @return
* CsrBool : returns true if the interface is supported, otherwise false.
*/
-extern CsrBool CsrWifiVifUtilsIsSupported(CsrUint16 interfaceTag);
+extern CsrBool CsrWifiVifUtilsIsSupported(u16 interfaceTag);
#ifdef CSR_LOG_ENABLE
/**
uf_verify_m4(unifi_priv_t *priv, const unsigned char *packet, unsigned int length)
{
const unsigned char *p = packet;
- CsrUint16 keyinfo;
+ u16 keyinfo;
if (length < (4 + 5 + 8 + 32 + 16 + 8 + 8 + 16 + 1 + 8)) {
case UNIFI_INIT_NETDEV:
{
/* get the proper interfaceTagId */
- CsrUint16 interfaceTag=0;
+ u16 interfaceTag=0;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
dev = priv->netdev[interfaceTag];
break;
}
- pcli->snap_filter.protocols = CsrPmemAlloc(snap_filter.count * sizeof(CsrUint16));
+ pcli->snap_filter.protocols = CsrPmemAlloc(snap_filter.count * sizeof(u16));
if (!pcli->snap_filter.protocols) {
r = -ENOMEM;
goto out;
}
if (copy_from_user((void*)pcli->snap_filter.protocols,
(void*)snap_filter.protocols,
- snap_filter.count * sizeof(CsrUint16)))
+ snap_filter.count * sizeof(u16)))
{
CsrPmemFree(pcli->snap_filter.protocols);
r = -EFAULT;
{
int timestamp = jiffies_to_msecs(jiffies);
unifi_debug_log_to_buf("T:");
- unifi_debug_log_to_buf("%04X%04X ", *(((CsrUint16*)×tamp) + 1),
- *(CsrUint16*)×tamp);
+ unifi_debug_log_to_buf("%04X%04X ", *(((u16*)×tamp) + 1),
+ *(u16*)×tamp);
}
/* Add signal */
unifi_debug_log_to_buf("S%s:%04X R:%04X D:%04X ",
dir ? "T" : "F",
- *(CsrUint16*)signal,
- *(CsrUint16*)(signal + 2),
- *(CsrUint16*)(signal + 4));
+ *(u16*)signal,
+ *(u16*)(signal + 2),
+ *(u16*)(signal + 4));
unifi_debug_hex_to_buf(signal + 6, signal_len - 6);
/* Add bulk data (assume 1 bulk data per signal) */
Unifi_netdev_instances[bus_id * CSR_WIFI_NUM_INTERFACES] = netdev_priv(priv->netdev[0]);
/* Initialise the mini-coredump capture buffers */
- csrResult = unifi_coredump_init(priv->card, (CsrUint16)coredump_max);
+ csrResult = unifi_coredump_init(priv->card, (u16)coredump_max);
if (csrResult != CSR_RESULT_SUCCESS) {
unifi_error(priv, "Couldn't allocate mini-coredump buffers\n");
}
* ---------------------------------------------------------------------------
*/
CsrBool
-uf_alloc_netdevice_for_other_interfaces(unifi_priv_t *priv, CsrUint16 interfaceTag)
+uf_alloc_netdevice_for_other_interfaces(unifi_priv_t *priv, u16 interfaceTag)
{
struct net_device *dev;
netInterface_priv_t *interfacePriv;
#ifdef CSR_SUPPORT_SME
static int
_identify_sme_ma_pkt_ind(unifi_priv_t *priv,
- const s8 *oui, CsrUint16 protocol,
+ const s8 *oui, u16 protocol,
const CSR_SIGNAL *signal,
bulk_data_param_t *bulkdata,
const unsigned char *daddr,
} /* skb_80211_to_ether() */
-static CsrWifiRouterCtrlPortAction verify_port(unifi_priv_t *priv, unsigned char *address, int queue, CsrUint16 interfaceTag)
+static CsrWifiRouterCtrlPortAction verify_port(unifi_priv_t *priv, unsigned char *address, int queue, u16 interfaceTag)
{
#ifdef CSR_NATIVE_LINUX
#ifdef CSR_SUPPORT_WEXT
int prepare_and_add_macheader(unifi_priv_t *priv, struct sk_buff *skb, struct sk_buff *newSkb,
CSR_PRIORITY priority,
bulk_data_param_t *bulkdata,
- CsrUint16 interfaceTag,
+ u16 interfaceTag,
const u8 *daddr,
const u8 *saddr,
CsrBool protection)
{
- CsrUint16 fc = 0;
+ u16 fc = 0;
u8 qc = 0;
u8 macHeaderLengthInBytes = MAC_HEADER_SIZE, *bufPtr = NULL;
bulk_data_param_t data_ptrs;
send_ma_pkt_request(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr *ehdr, CSR_PRIORITY priority)
{
int r;
- CsrUint16 i;
+ u16 i;
CsrBool eapolStore = FALSE;
struct sk_buff *newSkb = NULL;
bulk_data_param_t bulkdata;
const int proto = ntohs(ehdr->h_proto);
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CsrWifiMacAddress peerAddress;
CSR_TRANSMISSION_CONTROL transmissionControl = CSR_NO_CONFIRM_REQUIRED;
s8 protection;
static void
-indicate_rx_skb(unifi_priv_t *priv, CsrUint16 ifTag, u8* dst_a, u8* src_a, struct sk_buff *skb, CSR_SIGNAL *signal,
+indicate_rx_skb(unifi_priv_t *priv, u16 ifTag, u8* dst_a, u8* src_a, struct sk_buff *skb, CSR_SIGNAL *signal,
bulk_data_param_t *bulkdata)
{
int r, sr = 0;
void
uf_process_rx_pending_queue(unifi_priv_t *priv, int queue,
CsrWifiMacAddress source_address,
- int indicate, CsrUint16 interfaceTag)
+ int indicate, u16 interfaceTag)
{
rx_buffered_packets_t *rx_q_item;
struct list_head *rx_list;
void
uf_resume_data_plane(unifi_priv_t *priv, int queue,
CsrWifiMacAddress peer_address,
- CsrUint16 interfaceTag)
+ u16 interfaceTag)
{
#ifdef CSR_SUPPORT_WEXT
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
} /* uf_resume_data_plane() */
-void uf_free_pending_rx_packets(unifi_priv_t *priv, int queue, CsrWifiMacAddress peer_address,CsrUint16 interfaceTag)
+void uf_free_pending_rx_packets(unifi_priv_t *priv, int queue, CsrWifiMacAddress peer_address,u16 interfaceTag)
{
uf_process_rx_pending_queue(priv, queue, peer_address, 0,interfaceTag);
static void
unifi_rx(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
{
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
bulk_data_desc_t *pData;
const CSR_MA_PACKET_INDICATION *pkt_ind = &signal->u.MaPacketIndication;
struct sk_buff *skb;
u8 da[ETH_ALEN], sa[ETH_ALEN];
u8 toDs, fromDs, frameType, macHeaderLengthInBytes = MAC_HEADER_SIZE;
- CsrUint16 frameControl;
+ u16 frameControl;
netInterface_priv_t *interfacePriv;
struct ethhdr ehdr;
static void process_ma_packet_cfm(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
{
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
const CSR_MA_PACKET_CONFIRM *pkt_cfm = &signal->u.MaPacketConfirm;
netInterface_priv_t *interfacePriv;
*/
static void process_ma_packet_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
{
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
bulk_data_desc_t *pData;
CSR_MA_PACKET_INDICATION *pkt_ind = (CSR_MA_PACKET_INDICATION*)&signal->u.MaPacketIndication;
struct sk_buff *skb;
- CsrUint16 frameControl;
+ u16 frameControl;
netInterface_priv_t *interfacePriv;
u8 da[ETH_ALEN], sa[ETH_ALEN];
u8 *bssid = NULL, *ba_addr = NULL;
CsrBool powerSaveChanged = FALSE;
u8 pmBit = 0;
CsrWifiRouterCtrlStaInfo_t *srcStaInfo = NULL;
- CsrUint16 qosControl;
+ u16 qosControl;
#endif
frameType = ((frameControl & 0x000C) >> 2);
unifi_trace(priv, UDBG3, "Rx Frame Type: %d sn: %d\n",frameType,
- (le16_to_cpu(*((CsrUint16*)(bulkdata->d[0].os_data_ptr + IEEE802_11_SEQUENCE_CONTROL_OFFSET))) >> 4) & 0xfff);
+ (le16_to_cpu(*((u16*)(bulkdata->d[0].os_data_ptr + IEEE802_11_SEQUENCE_CONTROL_OFFSET))) >> 4) & 0xfff);
if(frameType == IEEE802_11_FRAMETYPE_CONTROL){
#ifdef CSR_SUPPORT_SME
unifi_trace(priv, UDBG6, "%s: Received Control Frame\n", __FUNCTION__);
frame_desc_struct frame_desc;
frame_desc.bulkdata = *bulkdata;
frame_desc.signal = *signal;
- frame_desc.sn = (le16_to_cpu(*((CsrUint16*)(bulkdata->d[0].os_data_ptr + IEEE802_11_SEQUENCE_CONTROL_OFFSET))) >> 4) & 0xfff;
+ frame_desc.sn = (le16_to_cpu(*((u16*)(bulkdata->d[0].os_data_ptr + IEEE802_11_SEQUENCE_CONTROL_OFFSET))) >> 4) & 0xfff;
frame_desc.active = TRUE;
unifi_trace(priv, UDBG6, "%s: calling process_ba_frame (session=%d)\n", __FUNCTION__, ba_session_idx);
process_ba_frame(priv, interfacePriv, ba_session, &frame_desc);
bulk_data_param_t subframe_bulkdata;
u8 *dot11_hdr_ptr = (u8*)bulkdata->d[0].os_data_ptr;
CsrResult csrResult;
- CsrUint16 frameControl;
+ u16 frameControl;
u8 *qos_control_ptr;
- frameControl = le16_to_cpu(*((CsrUint16*)dot11_hdr_ptr));
+ frameControl = le16_to_cpu(*((u16*)dot11_hdr_ptr));
qos_control_ptr = dot11_hdr_ptr + (((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK))?30: 24);
if(!(*qos_control_ptr & IEEE802_11_QC_A_MSDU_PRESENT)) {
unifi_trace(priv, UDBG6, "%s: calling unifi_rx()", __FUNCTION__);
static void update_expected_sn(unifi_priv_t *priv,
netInterface_priv_t *interfacePriv,
ba_session_rx_struct *ba_session,
- CsrUint16 sn)
+ u16 sn)
{
int i, j;
- CsrUint16 gap;
+ u16 gap;
gap = (sn - ba_session->expected_sn) & 0xFFF;
unifi_trace(priv, UDBG6, "%s: proccess the frames up to new_expected_sn = %d gap = %d\n", __FUNCTION__, sn, gap);
void scroll_ba_window(unifi_priv_t *priv,
netInterface_priv_t *interfacePriv,
ba_session_rx_struct *ba_session,
- CsrUint16 sn)
+ u16 sn)
{
if(((sn - ba_session->expected_sn) & 0xFFF) <= 2048) {
update_expected_sn(priv, interfacePriv, ba_session, sn);
static int consume_frame_or_get_buffer_index(unifi_priv_t *priv,
netInterface_priv_t *interfacePriv,
ba_session_rx_struct *ba_session,
- CsrUint16 sn,
+ u16 sn,
frame_desc_struct *frame_desc) {
int i;
- CsrUint16 sn_temp;
+ u16 sn_temp;
if(((sn - ba_session->expected_sn) & 0xFFF) <= 2048) {
sn_temp = ba_session->expected_sn + ba_session->wind_size;
unifi_trace(priv, UDBG6, "%s: new frame: sn=%d\n", __FUNCTION__, sn);
if(!(((sn - sn_temp) & 0xFFF) > 2048)) {
- CsrUint16 new_expected_sn;
+ u16 new_expected_sn;
unifi_trace(priv, UDBG6, "%s: frame is out of window\n", __FUNCTION__);
sn_temp = (sn - ba_session->wind_size) & 0xFFF;
new_expected_sn = (sn_temp + 1) & 0xFFF;
frame_desc_struct *frame_desc)
{
int i;
- CsrUint16 sn = frame_desc->sn;
+ u16 sn = frame_desc->sn;
if (ba_session->timeout) {
mod_timer(&ba_session->timer, (jiffies + usecs_to_jiffies((ba_session->timeout) * 1024)));
CsrTime now;
CsrTime age;
u8 i, j;
- CsrUint16 sn_temp;
+ u16 sn_temp;
/* gap is started at 1 because we have buffered frames and
* hence a minimum gap of 1 exists
static void process_ma_packet_error_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
{
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
const CSR_MA_PACKET_ERROR_INDICATION *pkt_err_ind = &signal->u.MaPacketErrorIndication;
netInterface_priv_t *interfacePriv;
ba_session_rx_struct *ba_session;
/* Memory dump with level filter controlled by unifi_debug */
void
-unifi_dump(void *ospriv, int level, const char *msg, void *mem, CsrUint16 len)
+unifi_dump(void *ospriv, int level, const char *msg, void *mem, u16 len)
{
unifi_priv_t *priv = (unifi_priv_t*) ospriv;
/* Memory dump that appears all the time, use sparingly */
void
-dump(void *mem, CsrUint16 len)
+dump(void *mem, u16 len)
{
int i, col = 0;
unsigned char *pdata = (unsigned char *)mem;
void
-dump16(void *mem, CsrUint16 len)
+dump16(void *mem, u16 len)
{
int i, col=0;
unsigned short *p = (unsigned short *)mem;
#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
void
-dump_str(void *mem, CsrUint16 len)
+dump_str(void *mem, u16 len)
{
int i, col = 0;
unsigned char *pdata = (unsigned char *)mem;
int unifi_putest_coredump_prepare(unifi_priv_t *priv, unsigned char *arg)
{
- CsrUint16 data_u16;
+ u16 data_u16;
CsrInt32 i;
CsrResult r;
} /* CsrSdioWrite8() */
CsrResult
-CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data)
+CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, u16 *data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err;
CsrResult
-CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data)
+CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, u16 data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err;
}
CsrResult
-CsrSdioBlockSizeSet(CsrSdioFunction *function, CsrUint16 blockSize)
+CsrSdioBlockSizeSet(CsrSdioFunction *function, u16 blockSize)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int r = 0;
}
CsrResult __attribute__((weak)) CsrSdioBlockSizeSet(CsrSdioFunction *function,
- CsrUint16 blockSize)
+ u16 blockSize)
{
return CSR_RESULT_SUCCESS;
}
#ifdef CSR_SUPPORT_WEXT
int sme_mgt_wifi_on(unifi_priv_t *priv)
{
- CsrUint16 numElements;
+ u16 numElements;
CsrWifiSmeDataBlock* dataList;
#ifdef CSR_SUPPORT_WEXT_AP
int r;
is_active,
CSR_WIFI_SME_BSS_TYPE_ANY_BSS,
CSR_WIFI_SME_SCAN_TYPE_ALL,
- (CsrUint16)num_channels, channel_list,
+ (u16)num_channels, channel_list,
0, NULL);
r = sme_wait_for_reply(priv, UNIFI_SME_MGT_LONG_TIMEOUT);
char *scan_results,
long scan_results_len)
{
- CsrUint16 scan_result_list_count;
+ u16 scan_result_list_count;
CsrWifiSmeScanResult *scan_result_list;
CsrWifiSmeScanResult *scan_result;
int r;
}
#ifdef CSR_SUPPORT_WEXT_AP
-int sme_ap_stop(unifi_priv_t *priv,CsrUint16 interface_tag)
+int sme_ap_stop(unifi_priv_t *priv,u16 interface_tag)
{
int r;
}
-int sme_ap_start(unifi_priv_t *priv,CsrUint16 interface_tag,
+int sme_ap_start(unifi_priv_t *priv,u16 interface_tag,
CsrWifiSmeApConfig_t * ap_config)
{
int r;
if (r == 0) {
signal_len = SigGetSize(&signal);
} else {
- CsrUint16 receiver_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sig_packed) + sizeof(CsrUint16)) & 0xFF00;
+ u16 receiver_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sig_packed) + sizeof(u16)) & 0xFF00;
/* The control indications are 1 byte, pass them to client. */
if (sig_len == 1) {
CSR_SIGNAL unpacked_signal;
u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
- CsrUint16 packed_siglen;
+ u16 packed_siglen;
list_for_each_safe(listHead, placeHolder, buffered_frames_list)
void *dest;
CsrResult csrResult;
CSR_SIGNAL *signal;
- CsrUint16 interfaceTag = 0;
+ u16 interfaceTag = 0;
CSR_MA_PACKET_REQUEST *req;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
signal = (CSR_SIGNAL *)hipreq->mlmeCommand;
unifi_trace(priv, UDBG4, "CsrWifiRouterCtrlHipReqHandler: 0x04%X ---->\n",
- *((CsrUint16*)hipreq->mlmeCommand));
+ *((u16*)hipreq->mlmeCommand));
/* Construct the signal. */
signal_ptr = (u8*)hipreq->mlmeCommand;
}
unifi_trace(priv, UDBG3, "SME SEND: Signal 0x%.4X \n",
- *((CsrUint16*)signal_ptr));
+ *((u16*)signal_ptr));
if (signal->SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_REQUEST_ID)
{
CSR_SIGNAL unpacked_signal;
if (r) {
unifi_error(priv,
"CsrWifiRouterCtrlHipReqHandler: Failed to send signal (0x%.4X - %u)\n",
- *((CsrUint16*)signal_ptr), r);
+ *((u16*)signal_ptr), r);
CsrWifiRouterCtrlWifiOffIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,CSR_WIFI_SME_CONTROL_INDICATION_ERROR);
}
#ifdef CSR_WIFI_SEND_GRATUITOUS_ARP
static void
-uf_send_gratuitous_arp(unifi_priv_t *priv, CsrUint16 interfaceTag)
+uf_send_gratuitous_arp(unifi_priv_t *priv, u16 interfaceTag)
{
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
CSR_PRIORITY priority;
CsrWifiRouterCtrlPortAction port_action,
const CsrWifiMacAddress *macAddress,
const int queue,
- CsrUint16 interfaceTag)
+ u16 interfaceTag)
{
const u8 broadcast_mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
unifi_port_config_t *port;
static int
_sys_packet_req(unifi_priv_t *priv, const CSR_SIGNAL *signal,
u8 subscriptionHandle,
- CsrUint16 frameLength, u8 *frame,
+ u16 frameLength, u8 *frame,
int proto)
{
int r;
struct sk_buff *skb, *newSkb = NULL;
CsrWifiMacAddress peerMacAddress;
CsrResult csrResult;
- CsrUint16 interfaceTag = req.VirtualInterfaceIdentifier & 0xff;
+ u16 interfaceTag = req.VirtualInterfaceIdentifier & 0xff;
CsrBool eapolStore = FALSE;
s8 protection = 0;
netInterface_priv_t *interfacePriv;
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiRouterMaPacketReq* mareq = (CsrWifiRouterMaPacketReq*)msg;
llc_snap_hdr_t *snap;
- CsrUint16 snap_protocol;
+ u16 snap_protocol;
CSR_SIGNAL signal;
CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
CsrWifiRouterCtrlPortAction controlPortaction;
u8 *daddr, *saddr;
- CsrUint16 interfaceTag = mareq->interfaceTag & 0x00ff;
+ u16 interfaceTag = mareq->interfaceTag & 0x00ff;
int queue;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
}
/* reset the station records when the mode is set as CSR_WIFI_ROUTER_CTRL_MODE_NONE */
-static void CsrWifiRouterCtrlResetStationRecordList(unifi_priv_t *priv, CsrUint16 interfaceTag)
+static void CsrWifiRouterCtrlResetStationRecordList(unifi_priv_t *priv, u16 interfaceTag)
{
u8 i,j;
CsrWifiRouterCtrlStaInfo_t *staInfo=NULL;
}
}
-void CsrWifiRouterCtrlInterfaceReset(unifi_priv_t *priv, CsrUint16 interfaceTag)
+void CsrWifiRouterCtrlInterfaceReset(unifi_priv_t *priv, u16 interfaceTag)
{
netInterface_priv_t *interfacePriv;
CsrWifiRouterCtrlStaInfo_t *staInfo = container_of(work, CsrWifiRouterCtrlStaInfo_t, send_disconnected_ind_task);
unifi_priv_t *priv;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
struct list_head send_cfm_list;
u8 j;
CsrBool blockack_session_stop(unifi_priv_t *priv,
- CsrUint16 interfaceTag,
+ u16 interfaceTag,
CsrWifiRouterCtrlBlockAckRole role,
- CsrUint16 tID,
+ u16 tID,
CsrWifiMacAddress macAddress)
{
netInterface_priv_t *interfacePriv;
CsrBool blockack_session_start(unifi_priv_t *priv,
- CsrUint16 interfaceTag,
- CsrUint16 tID,
- CsrUint16 timeout,
+ u16 interfaceTag,
+ u16 tID,
+ u16 timeout,
CsrWifiRouterCtrlBlockAckRole role,
- CsrUint16 wind_size,
- CsrUint16 start_sn,
+ u16 wind_size,
+ u16 start_sn,
CsrWifiMacAddress macAddress
)
{
if (CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_RX == direction)
{
- CsrUint16 interfaceTag = 0;
+ u16 interfaceTag = 0;
CsrWifiRouterCtrlTrafficProtocolIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,
interfaceTag,
packet_type,
netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
unifi_priv_t *priv = interfacePriv->privPtr;
int r;
- CsrUint16 interface_tag = interfacePriv->InterfaceTag;
+ u16 interface_tag = interfacePriv->InterfaceTag;
unifi_trace(priv, UDBG1, "iwprivsapstop\n" );
r = sme_ap_stop(priv,interface_tag);
netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
unifi_priv_t *priv = interfacePriv->privPtr;
int r = 0;
- CsrUint16 interface_tag = interfacePriv->InterfaceTag;
+ u16 interface_tag = interfacePriv->InterfaceTag;
unifi_trace(priv, UDBG1, "iwprivsstackstop\n" );
bulk_data_param_t *bulkdata)
{
u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
- CsrUint16 packed_siglen;
+ u16 packed_siglen;
CsrResult csrResult;
unsigned long lock_flags;
int r;
CSR_SIGNAL* reply_signal;
bulk_data_t* reply_bulkdata[UNIFI_MAX_DATA_REFERENCES];
- CsrUint16 signal_filter[SIG_FILTER_SIZE];
+ u16 signal_filter[SIG_FILTER_SIZE];
/* ------------------------------------------------------------------- */
CsrBool *freeBulkData,
netInterface_priv_t *interfacePriv)
{
- CsrUint16 frmCtrl, receptionStatus, frmCtrlSubType;
+ u16 frmCtrl, receptionStatus, frmCtrlSubType;
u8 *macHdrLocation;
u8 interfaceTag;
CsrBool isDataFrame;
CsrBool isWapiUnicastPkt = FALSE;
#ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
- CsrUint16 qosControl;
+ u16 qosControl;
#endif
u8 llcSnapHeaderOffset = 0;
#define CSR_MA_PACKET_INDICATION_RECEPTION_STATUS_OFFSET sizeof(CSR_SIGNAL_PRIMITIVE_HEADER) + 22
netInterface_priv_t *interfacePriv;
u8 interfaceTag;
- CsrUint16 receptionStatus = CSR_RX_SUCCESS;
+ u16 receptionStatus = CSR_RX_SUCCESS;
/* Pull out interface tag from virtual interface identifier */
interfaceTag = (CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + CSR_MA_PACKET_INDICATION_INTERFACETAG_OFFSET)) & 0xff;
CSR_SIGNAL signal;
u8 *destAddr;
CsrResult res;
- CsrUint16 interfaceTag = 0;
+ u16 interfaceTag = 0;
CsrBool isMcastPkt = TRUE;
unifi_trace(priv, UDBG6, "Received a WAPI data packet when the Unicast/Multicast filter is set\n");
} while (0)
-void unifi_dump(void *ospriv, int lvl, const char *msg, void *mem, CsrUint16 len);
-void dump(void *mem, CsrUint16 len);
-void dump16(void *mem, CsrUint16 len);
+void unifi_dump(void *ospriv, int lvl, const char *msg, void *mem, u16 len);
+void dump(void *mem, u16 len);
+void dump16(void *mem, u16 len);
#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
-void dump_str(void *mem, CsrUint16 len);
+void dump_str(void *mem, u16 len);
#endif /* CSR_WIFI_HIP_DEBUG_OFFLINE */
void unifi_error(void* ospriv, const char *fmt, ...);
#define ASSERT(cond)
-static inline void unifi_dump(void *ospriv, int lvl, const char *msg, void *mem, CsrUint16 len) {}
-static inline void dump(void *mem, CsrUint16 len) {}
-static inline void dump16(void *mem, CsrUint16 len) {}
+static inline void unifi_dump(void *ospriv, int lvl, const char *msg, void *mem, u16 len) {}
+static inline void dump(void *mem, u16 len) {}
+static inline void dump16(void *mem, u16 len) {}
#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
-static inline void dump_str(void *mem, CsrUint16 len) {}
+static inline void dump_str(void *mem, u16 len) {}
#endif /* CSR_WIFI_HIP_DEBUG_OFFLINE */
void unifi_error_nop(void* ospriv, const char *fmt, ...);
void
unifi_frame_ma_packet_req(unifi_priv_t *priv, CSR_PRIORITY priority,
CSR_RATE TransmitRate, CSR_CLIENT_TAG hostTag,
- CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
+ u16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
CSR_PROCESS_ID leSenderProcessId, u8 *peerMacAddress,
CSR_SIGNAL *signal)
{
int result;
u8 toDs, fromDs, macHeaderLengthInBytes = MAC_HEADER_SIZE;
u8 *qc;
- CsrUint16 *fc = (CsrUint16*)(buffered_pkt->bulkdata.os_data_ptr);
+ u16 *fc = (u16*)(buffered_pkt->bulkdata.os_data_ptr);
unsigned long lock_flags;
unifi_trace(priv, UDBG3, "frame_and_send_queued_pdu with moreData: %d , EOSP: %d\n",moreData,eosp);
unifi_frame_ma_packet_req(priv, buffered_pkt->priority, buffered_pkt->rate, buffered_pkt->hostTag,
#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
CsrResult unifi_reque_ma_packet_request (void *ospriv, CsrUint32 host_tag,
- CsrUint16 txStatus, bulk_data_desc_t *bulkDataDesc)
+ u16 txStatus, bulk_data_desc_t *bulkDataDesc)
{
CsrResult status = CSR_RESULT_SUCCESS;
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
bulk_data_param_t bulkData;
CSR_SIGNAL signal;
CSR_PRIORITY priority = 0;
- CsrUint16 interfaceTag = 0;
+ u16 interfaceTag = 0;
unifi_TrafficQueue priority_q;
- CsrUint16 frameControl = 0, frameType = 0;
+ u16 frameControl = 0, frameType = 0;
unsigned long lock_flags;
interfacePriv = priv->interfacePriv[interfaceTag];
/* Extract the Packet priority */
if (TRUE == staRecord->wmmOrQosEnabled) {
- CsrUint16 qosControl = 0;
+ u16 qosControl = 0;
u8 dataFrameType = 0;
dataFrameType =((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> 4);
*
* ---------------------------------------------------------------------------
*/
-void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, CsrUint16 receiverProcessId)
+void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, u16 receiverProcessId)
{
u8 handle = CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId);
u8 timSetStatus = CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId);
- CsrUint16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
+ u16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
/* This variable holds what TIM value we wanted to set in firmware */
- CsrUint16 timSetValue = 0;
+ u16 timSetValue = 0;
/* Irrespective of interface the count maintained */
static u8 retryCount = 0;
unsigned long lock_flags;
*
* ---------------------------------------------------------------------------
*/
-void update_tim(unifi_priv_t * priv, CsrUint16 aid, u8 setTim, CsrUint16 interfaceTag, CsrUint32 handle)
+void update_tim(unifi_priv_t * priv, u16 aid, u8 setTim, u16 interfaceTag, CsrUint32 handle)
{
CSR_SIGNAL signal;
CsrInt32 r;
static
void process_peer_active_transition(unifi_priv_t * priv,
CsrWifiRouterCtrlStaInfo_t *staRecord,
- CsrUint16 interfaceTag)
+ u16 interfaceTag)
{
int r,i;
CsrBool spaceAvail[4] = {TRUE,TRUE,TRUE,TRUE};
-void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,CsrUint16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm)
+void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,u16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm)
{
netInterface_priv_t *interfacePriv;
u8 i;
}
#endif
-CsrUint16 uf_get_vif_identifier (CsrWifiRouterCtrlMode mode, CsrUint16 tag)
+u16 uf_get_vif_identifier (CsrWifiRouterCtrlMode mode, u16 tag)
{
switch(mode)
{
static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
struct sk_buff *newSkb, CSR_PRIORITY *priority,
- bulk_data_param_t *bulkdata, CsrUint16 interfaceTag,
+ bulk_data_param_t *bulkdata, u16 interfaceTag,
u8 macHeaderLengthInBytes,
u8 qosDestination)
{
- CsrUint16 *fc = NULL;
+ u16 *fc = NULL;
u8 direction = 0, toDs, fromDs;
u8 *bufPtr = NULL;
u8 sa[ETH_ALEN], da[ETH_ALEN];
headroom = skb_headroom(skb);
/* pointer to frame control field */
- fc = (CsrUint16*) macHeaderBuf;
+ fc = (u16*) macHeaderBuf;
toDs = (*fc & cpu_to_le16(IEEE802_11_FC_TO_DS_MASK))?1 : 0;
fromDs = (*fc & cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK))? 1: 0;
u8 macHeaderLengthInBytes)
{
const CSR_MA_PACKET_INDICATION *ind = &(signal->u.MaPacketIndication);
- CsrUint16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0x00ff);
+ u16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0x00ff);
struct sk_buff *newSkb = NULL;
/* pointer to skb or private skb created using skb_copy() */
struct sk_buff *skbPtr = skb;
CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
u8 *peerMacAddress,
CSR_CLIENT_TAG hostTag,
- CsrUint16 interfaceTag,
+ u16 interfaceTag,
CSR_TRANSMISSION_CONTROL transmissionControl,
CSR_RATE TransmitRate,
CSR_PRIORITY priority,
int frameType = 0;
CsrBool queuePacketDozing = FALSE;
CsrUint32 priority_q;
- CsrUint16 frmCtrl;
+ u16 frmCtrl;
struct list_head * list = NULL; /* List to which buffered PDUs are to be enqueued*/
CsrBool setBcTim=FALSE;
netInterface_priv_t *interfacePriv;
}
#ifdef CSR_SUPPORT_SME
-s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *daddr)
+s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, u16 interfaceTag, const u8 *daddr)
{
s8 protection = 0;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
}
#endif
#ifdef CSR_SUPPORT_SME
-u8 send_multicast_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
+u8 send_multicast_frames(unifi_priv_t *priv, u16 interfaceTag)
{
int r;
tx_buffered_packets_t * buffered_pkt = NULL;
CSR_SIGNAL signal;
CSR_MA_VIF_AVAILABILITY_INDICATION *ind;
int r;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
u8 pduSent =0;
CSR_RESULT_CODE resultCode = CSR_RC_SUCCESS;
netInterface_priv_t *interfacePriv;
func_enter();
unifi_trace(priv, UDBG3,
"uf_process_ma_vif_availibility_ind: Process signal 0x%.4X\n",
- *((CsrUint16*)sigdata));
+ *((u16*)sigdata));
r = read_unpack_signal(sigdata, &signal);
if (r) {
struct list_head *txList)
{
- CsrUint16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
+ u16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
tx_buffered_packets_t * buffered_pkt = NULL;
unsigned long lock_flags;
CsrBool eosp=FALSE;
void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue q)
{
- CsrUint16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
+ u16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
CsrUint32 startIndex=0,endIndex=0;
CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
u8 queue;
}
-int uf_process_station_records_for_sending_data(unifi_priv_t *priv,CsrUint16 interfaceTag,
+int uf_process_station_records_for_sending_data(unifi_priv_t *priv,u16 interfaceTag,
CsrWifiRouterCtrlStaInfo_t *srcStaInfo,
CsrWifiRouterCtrlStaInfo_t *dstStaInfo)
{
* interfaceTag virtual interface tag
* ---------------------------------------------------------------------------
*/
-static void uf_handle_uspframes_delivery(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t *staInfo, CsrUint16 interfaceTag)
+static void uf_handle_uspframes_delivery(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t *staInfo, u16 interfaceTag)
{
s8 i;
void uf_process_wmm_deliver_ac_uapsd(unifi_priv_t * priv,
CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
- CsrUint16 qosControl,
- CsrUint16 interfaceTag)
+ u16 qosControl,
+ u16 interfaceTag)
{
CSR_PRIORITY priority;
unifi_TrafficQueue priority_q;
}
-void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
+void uf_send_qos_null(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
{
bulk_data_param_t bulkdata;
CsrResult csrResult;
return;
}
-void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
+void uf_send_nulldata(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
{
bulk_data_param_t bulkdata;
CsrResult csrResult;
CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
- u8 pmBit,CsrUint16 interfaceTag)
+ u8 pmBit,u16 interfaceTag)
{
CsrBool moreData = FALSE;
CsrBool powerSaveChanged = FALSE;
-void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,CsrUint16 interfaceTag)
+void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,u16 interfaceTag)
{
CsrWifiRouterCtrlStaInfo_t *staRecord =
CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, sa, interfaceTag);
/* generic function to get the station record handler */
CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(unifi_priv_t *priv,
const u8 *peerMacAddress,
- CsrUint16 interfaceTag)
+ u16 interfaceTag)
{
u8 i;
netInterface_priv_t *interfacePriv;
/* generic function to get the station record handler from the handle */
CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_priv_t *priv,
CsrUint32 handle,
- CsrUint16 interfaceTag)
+ u16 interfaceTag)
{
netInterface_priv_t *interfacePriv;
}
/* Function to do inactivity */
-void uf_check_inactivity(unifi_priv_t *priv, CsrUint16 interfaceTag, CsrTime currentTime)
+void uf_check_inactivity(unifi_priv_t *priv, u16 interfaceTag, CsrTime currentTime)
{
CsrUint32 i;
CsrWifiRouterCtrlStaInfo_t *staInfo;
}
/* Function to update activity of a station */
-void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *peerMacAddress)
+void uf_update_sta_activity(unifi_priv_t *priv, u16 interfaceTag, const u8 *peerMacAddress)
{
CsrTime elapsedTime, currentTime; /* Time in microseconds */
CsrTime timeHi; /* Not used - Time in microseconds */
uf_check_inactivity(priv, interfaceTag, currentTime);
}
}
-void resume_unicast_buffered_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
+void resume_unicast_buffered_frames(unifi_priv_t *priv, u16 interfaceTag)
{
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
}
func_exit();
}
-void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,CsrUint16 interfaceTag)
+void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,u16 interfaceTag)
{
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
* interfaceTag For which resume should happen
* ---------------------------------------------------------------------------
*/
-void resume_suspended_uapsd(unifi_priv_t* priv,CsrUint16 interfaceTag)
+void resume_suspended_uapsd(unifi_priv_t* priv,u16 interfaceTag)
{
u8 startIndex;
typedef struct tx_buffered_packets {
/* List link structure */
struct list_head q;
- CsrUint16 interfaceTag;
+ u16 interfaceTag;
CSR_CLIENT_TAG hostTag;
CSR_PROCESS_ID leSenderProcessId;
CSR_TRANSMISSION_CONTROL transmissionControl;
CsrUint32 assignedHandle;
CsrBool wmmOrQosEnabled;
CsrWifiAcPowersaveMode powersaveMode[MAX_ACCESS_CATOGORY];
- CsrUint16 maxSpLength;
+ u16 maxSpLength;
CsrBool uapsdActive;
- CsrUint16 noOfSpFramesSent;
+ u16 noOfSpFramesSent;
/* Router/Driver database */
#ifdef CSR_SUPPORT_SME
struct netInterface_priv *interfacePriv;
struct work_struct send_disconnected_ind_task;
CsrBool activity_flag;
- CsrUint16 listenIntervalInTus;
+ u16 listenIntervalInTus;
CSR_CLIENT_TAG nullDataHostTag;
/* Activity timestamps for the station */
u8 prevFrmType;
u8 prevFrmAccessCatogory;
CsrBool protection;
- CsrUint16 aid;
+ u16 aid;
CsrBool txSuspend;
u8 timSet;
/* Dont change the value of below macro for SET & RESET */
CsrBool timRequestPendingFlag;
u8 updateTimReqQueued;
- CsrUint16 noOfPktQueued;
+ u16 noOfPktQueued;
}CsrWifiRouterCtrlStaInfo_t;
#ifdef CSR_SUPPORT_WEXT_AP
struct CsrWifiSmeApConfig {
CsrWifiSsid ssid;
- CsrUint16 channel;
+ u16 channel;
CsrWifiNmeApCredentials credentials;
u8 max_connections;
u8 if_index;
{
u8 *bufptr; /* Signal Primitive */
bulk_data_param_t data_ptrs; /* Bulk Data pointers */
- CsrUint16 sig_len;
+ u16 sig_len;
}rx_buff_struct_t;
typedef struct
u8 allPeerDozing;
u8 pausedStaHandle[MAX_ACCESS_CATOGORY];
/* Max packet the driver can queue, irrespective of interface number */
- CsrUint16 noOfPktQueuedInDriver;
+ u16 noOfPktQueuedInDriver;
#define CSR_WIFI_DRIVER_SUPPORT_FOR_MAX_PKT_QUEUEING 512
#define CSR_WIFI_DRIVER_MAX_PKT_QUEUING_THRESHOLD_PER_PEER 64
#define CSR_WIFI_DRIVER_MINIMUM_BROADCAST_PKT_THRESHOLD 3
};
typedef struct {
- CsrUint16 queue_length[4];
+ u16 queue_length[4];
u8 os_queue_paused;
} unifi_OsQosInfo;
CsrBool active;
bulk_data_param_t bulkdata;
CSR_SIGNAL signal;
- CsrUint16 sn;
+ u16 sn;
CsrTime recv_time;
} frame_desc_struct;
typedef struct {
frame_desc_struct *buffer;
- CsrUint16 wind_size;
- CsrUint16 occupied_slots;
+ u16 wind_size;
+ u16 occupied_slots;
struct timer_list timer;
- CsrUint16 timeout;
- CsrUint16 expected_sn;
- CsrUint16 start_sn;
+ u16 timeout;
+ u16 expected_sn;
+ u16 start_sn;
CsrBool trigger_ba_after_ssn;
struct netInterface_priv *interfacePriv;
- CsrUint16 tID;
+ u16 tID;
CsrWifiMacAddress macAddress;
struct work_struct send_ba_err_task;
} ba_session_rx_struct;
typedef struct {
struct netInterface_priv *interfacePriv;
- CsrUint16 tID;
+ u16 tID;
CsrWifiMacAddress macAddress;
} ba_session_tx_struct;
typedef struct netInterface_priv
{
- CsrUint16 InterfaceTag;
+ u16 InterfaceTag;
struct unifi_priv *privPtr;
ba_session_tx_struct *ba_session_tx[MAX_SUPPORTED_BA_SESSIONS_TX];
ba_session_rx_struct *ba_session_rx[MAX_SUPPORTED_BA_SESSIONS_RX];
CsrTime last_inactivity_check;
/*number of multicast or borad cast packets queued*/
- CsrUint16 noOfbroadcastPktQueued;
+ u16 noOfbroadcastPktQueued;
#endif
/* A list to hold the buffered uncontrolled port packets */
struct list_head rx_uncontrolled_list;
int uf_free_netdevice(unifi_priv_t *priv);
/* Allocating function for other interfaces */
-CsrBool uf_alloc_netdevice_for_other_interfaces(unifi_priv_t *priv, CsrUint16 interfaceTag);
+CsrBool uf_alloc_netdevice_for_other_interfaces(unifi_priv_t *priv, u16 interfaceTag);
/*
* Firmware download related functions.
#ifdef CSR_SUPPORT_SME
CsrBool uf_check_broadcast_bssid(unifi_priv_t *priv, const bulk_data_param_t *bulkdata);
-CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,u8 pmBit,CsrUint16 interfaceTag);
-void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,CsrUint16 interfaceTag);
+CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,u8 pmBit,u16 interfaceTag);
+void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,u16 interfaceTag);
int uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
struct ethhdr *ehdr, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
const CSR_SIGNAL *signal,
CsrBool uf_is_more_data_for_non_delivery_ac(CsrWifiRouterCtrlStaInfo_t *staRecord);
void uf_process_wmm_deliver_ac_uapsd ( unifi_priv_t * priv,
CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
- CsrUint16 qosControl,
- CsrUint16 interfaceTag);
+ u16 qosControl,
+ u16 interfaceTag);
void uf_send_buffered_data_from_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, u8 queue, struct list_head *txList);
void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, u8 queue, struct list_head *txList);
void uf_continue_uapsd(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo);
-void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
-void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
+void uf_send_qos_null(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
+void uf_send_nulldata(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
#endif
-CsrResult uf_process_ma_packet_req(unifi_priv_t *priv, u8 *peerMacAddress, CSR_CLIENT_TAG hostTag, CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl, CSR_RATE TransmitRate, CSR_PRIORITY priority, CSR_PROCESS_ID senderId, bulk_data_param_t *bulkdata);
+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);
#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,CsrUint16 interfaceTag,
+int uf_process_station_records_for_sending_data(unifi_priv_t *priv,u16 interfaceTag,
CsrWifiRouterCtrlStaInfo_t *srcStaInfo,
CsrWifiRouterCtrlStaInfo_t *dstStaInfo);
void uf_prepare_send_cfm_list_for_queued_pkts(unifi_priv_t * priv,
struct list_head *buffered_frames_list);
void uf_flush_list(unifi_priv_t * priv, struct list_head * list);
tx_buffered_packets_t *dequeue_tx_data_pdu(unifi_priv_t *priv, struct list_head *txList);
-void resume_unicast_buffered_frames(unifi_priv_t *priv, CsrUint16 interfaceTag);
-void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,CsrUint16 interfaceTag);
-void resume_suspended_uapsd(unifi_priv_t* priv,CsrUint16 interfaceTag);
+void resume_unicast_buffered_frames(unifi_priv_t *priv, u16 interfaceTag);
+void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,u16 interfaceTag);
+void resume_suspended_uapsd(unifi_priv_t* priv,u16 interfaceTag);
#endif
/*
* netdev.c
struct sk_buff *newSkb,
CSR_PRIORITY priority,
bulk_data_param_t *bulkdata,
- CsrUint16 interfaceTag,
+ u16 interfaceTag,
const u8 *daddr,
const u8 *saddr,
CsrBool protection);
void
unifi_frame_ma_packet_req(unifi_priv_t *priv, CSR_PRIORITY priority,
CSR_RATE TransmitRate, CSR_CLIENT_TAG hostTag,
- CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
+ u16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
CSR_PROCESS_ID leSenderProcessId, u8 *peerMacAddress,
CSR_SIGNAL *signal);
/* 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, CsrUint16 aid, u8 setTim, CsrUint16 interfaceTag, CsrUint32 handle);
-void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, CsrUint16 senderProcessId);
+void update_tim(unifi_priv_t * priv, u16 aid, u8 setTim, u16 interfaceTag, CsrUint32 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 */
-void CsrWifiRouterCtrlInterfaceReset(unifi_priv_t *priv, CsrUint16 interfaceTag);
+void CsrWifiRouterCtrlInterfaceReset(unifi_priv_t *priv, u16 interfaceTag);
void scroll_ba_window(unifi_priv_t *priv,
netInterface_priv_t *interfacePriv,
ba_session_rx_struct *ba_session,
- CsrUint16 sn);
+ u16 sn);
CsrBool blockack_session_stop(unifi_priv_t *priv,
- CsrUint16 interfaceTag,
+ u16 interfaceTag,
CsrWifiRouterCtrlBlockAckRole role,
- CsrUint16 tID,
+ u16 tID,
CsrWifiMacAddress macAddress);
#ifdef CSR_SUPPORT_SME
/* Fetch the protection information from interface Mode */
-s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *daddr);
+s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, u16 interfaceTag, const u8 *daddr);
#endif
/* Fetch the station record handler from data base for matching Mac address */
#ifdef CSR_SUPPORT_SME
CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(unifi_priv_t *priv,
const u8 *peerMacAddress,
- CsrUint16 interfaceTag);
+ u16 interfaceTag);
/* Fetch the station record handler from data base for matching handle */
CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_priv_t *priv,
CsrUint32 handle,
- CsrUint16 interfaceTag);
+ u16 interfaceTag);
-void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *peerMacAddress);
-void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,CsrUint16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm);
+void uf_update_sta_activity(unifi_priv_t *priv, u16 interfaceTag, const u8 *peerMacAddress);
+void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,u16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm);
#endif
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
int uf_install_qdisc(struct net_device *dev);
void uf_resume_data_plane(unifi_priv_t *priv, int queue,
CsrWifiMacAddress peer_address,
- CsrUint16 interfaceTag);
+ u16 interfaceTag);
void uf_free_pending_rx_packets(unifi_priv_t *priv, int queue,
- CsrWifiMacAddress peer_address,CsrUint16 interfaceTag);
+ CsrWifiMacAddress peer_address,u16 interfaceTag);
int uf_register_netdev(unifi_priv_t *priv, int numOfInterface);
void uf_unregister_netdev(unifi_priv_t *priv);
void uf_net_get_name(struct net_device *dev, char *name, int len);
void uf_send_queue_info(unifi_priv_t *priv);
-CsrUint16 uf_get_vif_identifier(CsrWifiRouterCtrlMode mode, CsrUint16 tag);
+u16 uf_get_vif_identifier(CsrWifiRouterCtrlMode mode, u16 tag);
void uf_process_rx_pending_queue(unifi_priv_t *priv, int queue,
CsrWifiMacAddress source_address,
- int indicate, CsrUint16 interfaceTag);
+ int indicate, u16 interfaceTag);
#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
int uf_register_hip_offline_debug(unifi_priv_t *priv);
}
if (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_INDICATION_ID)
{
- CsrUint16 frmCtrl;
+ u16 frmCtrl;
CsrBool unicastPdu = TRUE;
u8 *macHdrLocation;
u8 *raddr = NULL, *taddr = NULL;
if(ind->ReceptionStatus == CSR_RX_SUCCESS)
{
u8 pmBit = (frmCtrl & 0x1000)?0x01:0x00;
- CsrUint16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0xff);
+ u16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0xff);
CsrWifiRouterCtrlStaInfo_t *srcStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,taddr,interfaceTag);
if((srcStaInfo != NULL) && (uf_check_broadcast_bssid(priv, bulkdata)== FALSE))
{
if (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_CONFIRM_ID)
{
CSR_MA_PACKET_CONFIRM *cfm = &unpacked_signal.u.MaPacketConfirm;
- CsrUint16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
+ u16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
netInterface_priv_t *interfacePriv;
CSR_MA_PACKET_REQUEST *req;
CsrWifiMacAddress peerMacAddress;
#endif
/* If EAPOL was requested via router APIs then send cfm else ignore*/
if((cfm->HostTag & 0x80000000) != CSR_WIFI_EAPOL_M4_HOST_TAG) {
- CsrWifiRouterMaPacketCfmSend((CsrUint16)signal[2],
+ CsrWifiRouterMaPacketCfmSend((u16)signal[2],
cfm->VirtualInterfaceIdentifier,
result,
(cfm->HostTag & 0x3fffffff), cfm->Rate);
* ---------------------------------------------------------------------------
*/
CsrWifiRouterCtrlPortAction
-uf_sme_port_state(unifi_priv_t *priv, unsigned char *address, int queue, CsrUint16 interfaceTag)
+uf_sme_port_state(unifi_priv_t *priv, unsigned char *address, int queue, u16 interfaceTag)
{
int i;
unifi_port_config_t *port;
* ---------------------------------------------------------------------------
*/
unifi_port_cfg_t*
-uf_sme_port_config_handle(unifi_priv_t *priv, unsigned char *address, int queue, CsrUint16 interfaceTag)
+uf_sme_port_config_handle(unifi_priv_t *priv, unsigned char *address, int queue, u16 interfaceTag)
{
int i;
unifi_port_config_t *port;
unifi_priv_t *priv = container_of(work, unifi_priv_t,
multicast_list_task);
int i;
- CsrUint16 interfaceTag = 0;
+ u16 interfaceTag = 0;
CsrWifiMacAddress* multicast_address_list = NULL;
int mc_count;
u8 *mc_list;
break;
case UNIFI_CFG_GET_INSTANCE:
{
- CsrUint16 InterfaceId=0;
+ u16 InterfaceId=0;
uf_net_get_name(priv->netdev[InterfaceId], &inst_name[0], sizeof(inst_name));
/* Copy the info to the out buffer */
{
struct ta_ind *ind = container_of(work, struct ta_ind, task);
unifi_priv_t *priv = container_of(ind, unifi_priv_t, ta_ind_work);
- CsrUint16 interfaceTag = 0;
+ u16 interfaceTag = 0;
CsrWifiRouterCtrlTrafficProtocolIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,
{
struct ta_sample_ind *ind = container_of(work, struct ta_sample_ind, task);
unifi_priv_t *priv = container_of(ind, unifi_priv_t, ta_sample_ind_work);
- CsrUint16 interfaceTag = 0;
+ u16 interfaceTag = 0;
unifi_trace(priv, UDBG5, "rxtcp %d txtcp %d rxudp %d txudp %d prio %d\n",
priv->rxTcpThroughput,
uf_send_m4_ready_wq(struct work_struct *work)
{
netInterface_priv_t *InterfacePriv = container_of(work, netInterface_priv_t, send_m4_ready_task);
- CsrUint16 iface = InterfacePriv->InterfaceTag;
+ u16 iface = InterfacePriv->InterfaceTag;
unifi_priv_t *priv = InterfacePriv->privPtr;
CSR_MA_PACKET_REQUEST *req = &InterfacePriv->m4_signal.u.MaPacketRequest;
CsrWifiMacAddress peer;
void uf_send_pkt_to_encrypt(struct work_struct *work)
{
netInterface_priv_t *interfacePriv = container_of(work, netInterface_priv_t, send_pkt_to_encrypt);
- CsrUint16 interfaceTag = interfacePriv->InterfaceTag;
+ u16 interfaceTag = interfacePriv->InterfaceTag;
unifi_priv_t *priv = interfacePriv->privPtr;
CsrUint32 pktBulkDataLength;
/* SME's reply to a scan request */
- CsrUint16 reply_scan_results_count;
+ u16 reply_scan_results_count;
CsrWifiSmeScanResult* reply_scan_results;
} sme_reply_t;
typedef struct {
- CsrUint16 appHandle;
+ u16 appHandle;
CsrWifiRouterEncapsulation encapsulation;
- CsrUint16 protocol;
+ u16 protocol;
u8 oui[3];
u8 in_use;
} sme_ma_unidata_ind_filter_t;
CsrWifiRouterCtrlPortAction uf_sme_port_state(unifi_priv_t *priv,
unsigned char *address,
int queue,
- CsrUint16 interfaceTag);
+ u16 interfaceTag);
unifi_port_cfg_t *uf_sme_port_config_handle(unifi_priv_t *priv,
unsigned char *address,
int queue,
- CsrUint16 interfaceTag);
+ u16 interfaceTag);
int sme_mgt_mib_set(unifi_priv_t *priv,
unsigned char *varbind, int length);
#ifdef CSR_SUPPORT_WEXT_AP
-int sme_ap_start(unifi_priv_t *priv,CsrUint16 interface_tag,CsrWifiSmeApConfig_t *ap_config);
-int sme_ap_stop(unifi_priv_t *priv,CsrUint16 interface_tag);
+int sme_ap_start(unifi_priv_t *priv,u16 interface_tag,CsrWifiSmeApConfig_t *ap_config);
+int sme_ap_stop(unifi_priv_t *priv,u16 interface_tag);
int sme_ap_config(unifi_priv_t *priv,CsrWifiSmeApMacConfig *ap_mac_config, CsrWifiNmeApConfig *group_security_config);
int uf_configure_supported_rates(u8 * supportedRates, u8 phySupportedBitmap);
#endif
unsigned char *scan_ie, unsigned int scan_ie_len);
void wext_send_disassoc_event(unifi_priv_t *priv);
void wext_send_michaelmicfailure_event(unifi_priv_t *priv,
- CsrUint16 count, CsrWifiMacAddress address,
- CsrWifiSmeKeyType keyType, CsrUint16 interfaceTag);
-void wext_send_pmkid_candidate_event(unifi_priv_t *priv, CsrWifiMacAddress bssid, CsrBool preauth_allowed, CsrUint16 interfaceTag);
+ u16 count, CsrWifiMacAddress address,
+ CsrWifiSmeKeyType keyType, u16 interfaceTag);
+void wext_send_pmkid_candidate_event(unifi_priv_t *priv, CsrWifiMacAddress bssid, CsrBool preauth_allowed, u16 interfaceTag);
void wext_send_started_event(unifi_priv_t *priv);
typedef struct {
/* Number of 16-bit ints in the protocols array */
- CsrUint16 count;
+ u16 count;
/* List of protocol ids to pass */
- CsrUint16 *protocols;
+ u16 *protocols;
} unifiio_snap_filter_t;
{
u8 phySupportedBitmap;
u8 channel;
- CsrUint16 beaconInterval;
+ u16 beaconInterval;
u8 dtimPeriod;
CsrBool wmmEnabled;
u8 shortSlotTimeEnabled;
- CsrUint16 groupkeyTimeout;
+ u16 groupkeyTimeout;
CsrBool strictGtkRekeyEnabled;
- CsrUint16 gmkTimeout;
- CsrUint16 responseTimeout;
+ u16 gmkTimeout;
+ u16 responseTimeout;
u8 retransLimit;
u8 rxStbc;
CsrBool rifsModeAllowed;
u8 dualCtsProtection;
u8 ctsProtectionType;
- CsrUint16 maxListenInterval;
+ u16 maxListenInterval;
}uf_cfg_ap_config_t;
typedef struct tcpic_clsfr
void
wext_send_michaelmicfailure_event(unifi_priv_t *priv,
- CsrUint16 count,
+ u16 count,
CsrWifiMacAddress address,
CsrWifiSmeKeyType keyType,
- CsrUint16 interfaceTag)
+ u16 interfaceTag)
{
unsigned char tsc[8] = {0};
} /* wext_send_michaelmicfailure_event() */
void
-wext_send_pmkid_candidate_event(unifi_priv_t *priv, CsrWifiMacAddress bssid, CsrBool preauth_allowed, CsrUint16 interfaceTag)
+wext_send_pmkid_candidate_event(unifi_priv_t *priv, CsrWifiMacAddress bssid, CsrBool preauth_allowed, u16 interfaceTag)
{
#if WIRELESS_EXT > 17
union iwreq_data wrqu;
projects / linux-2.6-block.git / commitdiff