Use the in-kernel u8 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>
handle_bh_error(unifi_priv_t *priv)
{
u8 conf_param = CONFIG_IND_ERROR;
- CsrUint8 interfaceTag = 0; /* used as a loop counter */
+ u8 interfaceTag = 0; /* used as a loop counter */
/* Block unifi_run_bh() until the error has been handled. */
typedef struct
{
CsrPrim type;
- CsrUint8 value;
+ u8 value;
} CsrEventCsrUint8;
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrEventCsrUint8
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint8 *CsrEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint8 value);
+CsrEventCsrUint8 *CsrEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, u8 value);
typedef struct
{
{
CsrPrim type;
CsrUint16 value1;
- CsrUint8 value2;
+ u8 value2;
} CsrEventCsrUint16CsrUint8;
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrEventCsrUint16CsrUint8
*
*----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrUint8 *CsrEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrUint8 value2);
+CsrEventCsrUint16CsrUint8 *CsrEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, u8 value2);
typedef struct
{
/*---------------------------------*/
/* Tech logging */
/*---------------------------------*/
-typedef CsrUint8 bitmask8_t;
+typedef u8 bitmask8_t;
typedef CsrUint16 bitmask16_t;
typedef CsrUint32 bitmask32_t;
/*---------------------------------*/
/* BSP logging */
/*---------------------------------*/
-void CsrLogSchedInit(CsrUint8 thread_id);
-void CsrLogSchedDeinit(CsrUint8 thread_id);
+void CsrLogSchedInit(u8 thread_id);
+void CsrLogSchedDeinit(u8 thread_id);
-void CsrLogSchedStart(CsrUint8 thread_id);
-void CsrLogSchedStop(CsrUint8 thread_id);
+void CsrLogSchedStart(u8 thread_id);
+void CsrLogSchedStop(u8 thread_id);
-void CsrLogInitTask(CsrUint8 thread_id, CsrSchedQid tskid, const CsrCharString *tskName);
+void CsrLogInitTask(u8 thread_id, CsrSchedQid tskid, const CsrCharString *tskName);
void CsrLogDeinitTask(CsrUint16 task_id);
void CsrLogActivate(CsrSchedQid tskid);
CsrSchedTid tid,
CsrBool cancel_res);
-void CsrLogBgintRegister(CsrUint8 thread_id,
+void CsrLogBgintRegister(u8 thread_id,
CsrSchedBgint irq,
const CsrCharString *callback,
const void *ptr);
/*---------------------------------*/
/* Log init/deinit */
/*---------------------------------*/
-void CsrLogInit(CsrUint8 size);
+void CsrLogInit(u8 size);
void CsrLogDeinit(void);
/*---------------------------------*/
/*------------------------------------------------------------------*/
/* Endian conversion */
/*------------------------------------------------------------------*/
-#define CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr) (((CsrUint16) ((CsrUint8 *) (ptr))[0]) | ((CsrUint16) ((CsrUint8 *) (ptr))[1]) << 8)
-#define CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr) (((CsrUint32) ((CsrUint8 *) (ptr))[0]) | ((CsrUint32) ((CsrUint8 *) (ptr))[1]) << 8 | \
- ((CsrUint32) ((CsrUint8 *) (ptr))[2]) << 16 | ((CsrUint32) ((CsrUint8 *) (ptr))[3]) << 24)
-#define CSR_COPY_UINT16_TO_LITTLE_ENDIAN(uint, ptr) ((CsrUint8 *) (ptr))[0] = ((CsrUint8) ((uint) & 0x00FF)); \
- ((CsrUint8 *) (ptr))[1] = ((CsrUint8) ((uint) >> 8))
-#define CSR_COPY_UINT32_TO_LITTLE_ENDIAN(uint, ptr) ((CsrUint8 *) (ptr))[0] = ((CsrUint8) ((uint) & 0x000000FF)); \
- ((CsrUint8 *) (ptr))[1] = ((CsrUint8) (((uint) >> 8) & 0x000000FF)); \
- ((CsrUint8 *) (ptr))[2] = ((CsrUint8) (((uint) >> 16) & 0x000000FF)); \
- ((CsrUint8 *) (ptr))[3] = ((CsrUint8) (((uint) >> 24) & 0x000000FF))
-#define CSR_GET_UINT16_FROM_BIG_ENDIAN(ptr) (((CsrUint16) ((CsrUint8 *) (ptr))[1]) | ((CsrUint16) ((CsrUint8 *) (ptr))[0]) << 8)
-#define CSR_GET_UINT24_FROM_BIG_ENDIAN(ptr) (((CsrUint24) ((CsrUint8 *) (ptr))[2]) | \
- ((CsrUint24) ((CsrUint8 *) (ptr))[1]) << 8 | ((CsrUint24) ((CsrUint8 *) (ptr))[0]) << 16)
-#define CSR_GET_UINT32_FROM_BIG_ENDIAN(ptr) (((CsrUint32) ((CsrUint8 *) (ptr))[3]) | ((CsrUint32) ((CsrUint8 *) (ptr))[2]) << 8 | \
- ((CsrUint32) ((CsrUint8 *) (ptr))[1]) << 16 | ((CsrUint32) ((CsrUint8 *) (ptr))[0]) << 24)
-#define CSR_COPY_UINT16_TO_BIG_ENDIAN(uint, ptr) ((CsrUint8 *) (ptr))[1] = ((CsrUint8) ((uint) & 0x00FF)); \
- ((CsrUint8 *) (ptr))[0] = ((CsrUint8) ((uint) >> 8))
-#define CSR_COPY_UINT24_TO_BIG_ENDIAN(uint, ptr) ((CsrUint8 *) (ptr))[2] = ((CsrUint8) ((uint) & 0x000000FF)); \
- ((CsrUint8 *) (ptr))[1] = ((CsrUint8) (((uint) >> 8) & 0x000000FF)); \
- ((CsrUint8 *) (ptr))[0] = ((CsrUint8) (((uint) >> 16) & 0x000000FF))
-#define CSR_COPY_UINT32_TO_BIG_ENDIAN(uint, ptr) ((CsrUint8 *) (ptr))[3] = ((CsrUint8) ((uint) & 0x000000FF)); \
- ((CsrUint8 *) (ptr))[2] = ((CsrUint8) (((uint) >> 8) & 0x000000FF)); \
- ((CsrUint8 *) (ptr))[1] = ((CsrUint8) (((uint) >> 16) & 0x000000FF)); \
- ((CsrUint8 *) (ptr))[0] = ((CsrUint8) (((uint) >> 24) & 0x000000FF))
+#define CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr) (((CsrUint16) ((u8 *) (ptr))[0]) | ((CsrUint16) ((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))
+#define CSR_COPY_UINT32_TO_LITTLE_ENDIAN(uint, ptr) ((u8 *) (ptr))[0] = ((u8) ((uint) & 0x000000FF)); \
+ ((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_UINT24_FROM_BIG_ENDIAN(ptr) (((CsrUint24) ((u8 *) (ptr))[2]) | \
+ ((CsrUint24) ((u8 *) (ptr))[1]) << 8 | ((CsrUint24) ((u8 *) (ptr))[0]) << 16)
+#define CSR_GET_UINT32_FROM_BIG_ENDIAN(ptr) (((CsrUint32) ((u8 *) (ptr))[3]) | ((CsrUint32) ((u8 *) (ptr))[2]) << 8 | \
+ ((CsrUint32) ((u8 *) (ptr))[1]) << 16 | ((CsrUint32) ((u8 *) (ptr))[0]) << 24)
+#define CSR_COPY_UINT16_TO_BIG_ENDIAN(uint, ptr) ((u8 *) (ptr))[1] = ((u8) ((uint) & 0x00FF)); \
+ ((u8 *) (ptr))[0] = ((u8) ((uint) >> 8))
+#define CSR_COPY_UINT24_TO_BIG_ENDIAN(uint, ptr) ((u8 *) (ptr))[2] = ((u8) ((uint) & 0x000000FF)); \
+ ((u8 *) (ptr))[1] = ((u8) (((uint) >> 8) & 0x000000FF)); \
+ ((u8 *) (ptr))[0] = ((u8) (((uint) >> 16) & 0x000000FF))
+#define CSR_COPY_UINT32_TO_BIG_ENDIAN(uint, ptr) ((u8 *) (ptr))[3] = ((u8) ((uint) & 0x000000FF)); \
+ ((u8 *) (ptr))[2] = ((u8) (((uint) >> 8) & 0x000000FF)); \
+ ((u8 *) (ptr))[1] = ((u8) (((uint) >> 16) & 0x000000FF)); \
+ ((u8 *) (ptr))[0] = ((u8) (((uint) >> 24) & 0x000000FF))
/*------------------------------------------------------------------*/
/* XAP conversion macros */
/*------------------------------------------------------------------*/
-#define CSR_LSB16(a) ((CsrUint8) ((a) & 0x00ff))
-#define CSR_MSB16(b) ((CsrUint8) ((b) >> 8))
+#define CSR_LSB16(a) ((u8) ((a) & 0x00ff))
+#define CSR_MSB16(b) ((u8) ((b) >> 8))
#define CSR_CONVERT_8_FROM_XAP(output, input) \
- (output) = ((CsrUint8) (input));(input) += 2
+ (output) = ((u8) (input));(input) += 2
#define CSR_CONVERT_16_FROM_XAP(output, input) \
(output) = (CsrUint16) ((((CsrUint16) (input)[1]) << 8) | \
(output)[1] = 0;(output) += 2
#define CSR_ADD_UINT16_TO_XAP(output, input) \
- (output)[0] = ((CsrUint8) ((input) & 0x00FF)); \
- (output)[1] = ((CsrUint8) ((input) >> 8));(output) += 2
+ (output)[0] = ((u8) ((input) & 0x00FF)); \
+ (output)[1] = ((u8) ((input) >> 8));(output) += 2
#define CSR_ADD_UINT32_TO_XAP(output, input) \
- (output)[0] = ((CsrUint8) (((input) >> 16) & 0x00FF)); \
- (output)[1] = ((CsrUint8) ((input) >> 24)); \
- (output)[2] = ((CsrUint8) ((input) & 0x00FF)); \
- (output)[3] = ((CsrUint8) (((input) >> 8) & 0x00FF));(output) += 4
+ (output)[0] = ((u8) (((input) >> 16) & 0x00FF)); \
+ (output)[1] = ((u8) ((input) >> 24)); \
+ (output)[2] = ((u8) ((input) & 0x00FF)); \
+ (output)[3] = ((u8) (((input) >> 8) & 0x00FF));(output) += 4
/*------------------------------------------------------------------*/
/* Misc */
static void *deserialize_data(CsrUint16 primType,
CsrSize length,
- CsrUint8 *data)
+ u8 *data)
{
CsrMsgConvPrimEntry *ptr;
- CsrUint8 *ret;
+ u8 *ret;
ptr = CsrMsgConvFind(primType);
return ret;
}
-static CsrBool free_message(CsrUint16 primType, CsrUint8 *data)
+static CsrBool free_message(CsrUint16 primType, u8 *data)
{
CsrMsgConvPrimEntry *ptr;
CsrBool ret;
return ret;
}
-static CsrUint8 *serialize_message(CsrUint16 primType,
+static u8 *serialize_message(CsrUint16 primType,
void *msg,
CsrSize *length,
- CsrUint8 *buffer)
+ u8 *buffer)
{
CsrMsgConvPrimEntry *ptr;
- CsrUint8 *ret;
+ u8 *ret;
ptr = CsrMsgConvFind(primType);
return sizeof_message(primType, msg);
}
-CsrUint8 *CsrMsgConvSerialize(CsrUint8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg)
+u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg)
{
if (converter)
{
CsrSize serializedLength;
- CsrUint8 *bufSerialized;
- CsrUint8 *bufOffset = &buffer[*offset];
+ u8 *bufSerialized;
+ u8 *bufOffset = &buffer[*offset];
bufSerialized = converter->serialize_message(primType, msg, &serializedLength, bufOffset);
*offset += serializedLength;
return bufSerialized;
#endif
typedef CsrSize (CsrMsgSizeofFunc)(void *msg);
-typedef CsrUint8 *(CsrMsgSerializeFunc)(CsrUint8 *buffer, CsrSize *length, void *msg);
+typedef u8 *(CsrMsgSerializeFunc)(u8 *buffer, CsrSize *length, void *msg);
typedef void (CsrMsgFreeFunc)(void *msg);
-typedef void *(CsrMsgDeserializeFunc)(CsrUint8 *buffer, CsrSize length);
+typedef void *(CsrMsgDeserializeFunc)(u8 *buffer, CsrSize length);
/* Converter entry for one message type */
typedef struct CsrMsgConvMsgEntry
typedef struct
{
CsrMsgConvPrimEntry *profile_converters;
- void *(*deserialize_data)(CsrUint16 primType, CsrSize length, CsrUint8 * data);
- CsrBool (*free_message)(CsrUint16 primType, CsrUint8 *data);
+ void *(*deserialize_data)(CsrUint16 primType, CsrSize length, u8 * data);
+ CsrBool (*free_message)(CsrUint16 primType, u8 *data);
CsrSize (*sizeof_message)(CsrUint16 primType, void *msg);
- CsrUint8 *(*serialize_message)(CsrUint16 primType, void *msg,
+ u8 *(*serialize_message)(CsrUint16 primType, void *msg,
CsrSize * length,
- CsrUint8 * buffer);
+ u8 * buffer);
} CsrMsgConvEntry;
CsrSize CsrMsgConvSizeof(CsrUint16 primType, void *msg);
-CsrUint8 *CsrMsgConvSerialize(CsrUint8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, 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);
CsrUint32 CsrUtf16StringSerLen(const CsrUtf16String *str);
/* Prototypes for primitive type serializers */
-void CsrUint8Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint8 value);
-void CsrUint16Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint16 value);
-void CsrUint32Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint32 value);
-void CsrMemCpySer(CsrUint8 *buffer, CsrSize *offset, const void *value, CsrSize length);
-void CsrCharStringSer(CsrUint8 *buffer, CsrSize *offset, const CsrCharString *value);
-void CsrUtf8StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf8String *value);
-void CsrUtf16StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf16String *value);
-void CsrVoidPtrSer(CsrUint8 *buffer, CsrSize *offset, void *ptr);
-void CsrSizeSer(CsrUint8 *buffer, CsrSize *offset, CsrSize value);
-
-void CsrUint8Des(CsrUint8 *value, CsrUint8 *buffer, CsrSize *offset);
-void CsrUint16Des(CsrUint16 *value, CsrUint8 *buffer, CsrSize *offset);
-void CsrUint32Des(CsrUint32 *value, CsrUint8 *buffer, CsrSize *offset);
-void CsrMemCpyDes(void *value, CsrUint8 *buffer, CsrSize *offset, CsrSize length);
-void CsrCharStringDes(CsrCharString **value, CsrUint8 *buffer, CsrSize *offset);
-void CsrUtf8StringDes(CsrUtf8String **value, CsrUint8 *buffer, CsrSize *offset);
-void CsrUtf16StringDes(CsrUtf16String **value, CsrUint8 *buffer, CsrSize *offset);
-void CsrVoidPtrDes(void **value, CsrUint8 *buffer, CsrSize *offset);
-void CsrSizeDes(CsrSize *value, CsrUint8 *buffer, CsrSize *offset);
+void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value);
+void CsrUint16Ser(u8 *buffer, CsrSize *offset, CsrUint16 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 CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value);
+void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const CsrUtf16String *value);
+void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr);
+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 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);
+void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset);
+void CsrUtf16StringDes(CsrUtf16String **value, u8 *buffer, CsrSize *offset);
+void CsrVoidPtrDes(void **value, u8 *buffer, CsrSize *offset);
+void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset);
CsrSize CsrEventSizeof(void *msg);
-CsrUint8 *CsrEventSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventDes(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventDes(u8 *buffer, CsrSize length);
CsrSize CsrEventCsrUint8Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint8Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint8Des(u8 *buffer, CsrSize length);
CsrSize CsrEventCsrUint16Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16Des(u8 *buffer, CsrSize length);
CsrSize CsrEventCsrUint32Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint32Des(u8 *buffer, CsrSize length);
CsrSize CsrEventCsrUint16CsrUint8Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length);
CsrSize CsrEventCsrUint16CsrUint16Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint16CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint16Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length);
CsrSize CsrEventCsrUint16CsrUint32Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint16CsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint32Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length);
CsrSize CsrEventCsrUint16CsrCharStringSizeof(void *msg);
-CsrUint8 *CsrEventCsrUint16CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrCharStringDes(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length);
CsrSize CsrEventCsrUint32CsrUint16Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint32CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32CsrUint16Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length);
CsrSize CsrEventCsrUint32CsrCharStringSizeof(void *msg);
-CsrUint8 *CsrEventCsrUint32CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32CsrCharStringDes(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, CsrSize length);
#ifdef __cplusplus
}
#include "csr_types.h"
#include "csr_panic.h"
-void CsrPanic(CsrUint8 tech, CsrUint16 reason, const char *p)
+void CsrPanic(u8 tech, CsrUint16 reason, const char *p)
{
BUG_ON(1);
}
/* Panic interface used by technologies */
/* DEPRECATED - replaced by csr_log_text.h */
-void CsrPanic(CsrUint8 tech, CsrUint16 reason, const char *p);
+void CsrPanic(u8 tech, CsrUint16 reason, const char *p);
#ifdef __cplusplus
}
*----------------------------------------------------------------------------*/
#ifdef CSR_PMEM_DEBUG_ENABLE
-typedef CsrUint8 CsrPmemDebugAllocType;
+typedef u8 CsrPmemDebugAllocType;
#define CSR_PMEM_DEBUG_TYPE_PMEM_ALLOC 1
#define CSR_PMEM_DEBUG_TYPE_MEM_ALLOC 2
#define CSR_PMEM_DEBUG_TYPE_MEM_CALLOC 3
* void
*
*----------------------------------------------------------------------------*/
-void CsrPmemDebugInstallHooks(CsrUint8 headSize, CsrUint8 endSize, CsrPmemDebugOnAlloc *onAllocCallback, CsrPmemDebugOnFree *onFreeCallback);
+void CsrPmemDebugInstallHooks(u8 headSize, u8 endSize, CsrPmemDebugOnAlloc *onAllocCallback, CsrPmemDebugOnFree *onFreeCallback);
void *CsrPmemDebugAlloc(CsrSize size, CsrPmemDebugAllocType type, const CsrCharString* file, CsrUint32 line);
#define CsrPmemAlloc(size) CsrPmemDebugAlloc(size, CSR_PMEM_DEBUG_TYPE_PMEM_ALLOC, __FILE__, __LINE__)
{
CsrUint16 manfId; /* Vendor ID to match or CSR_SDIO_ANY_MANF_ID */
CsrUint16 cardId; /* Device ID to match or CSR_SDIO_ANY_CARD_ID */
- CsrUint8 sdioFunction; /* SDIO Function number to match or CSR_SDIO_ANY_SDIO_FUNCTION */
- CsrUint8 sdioInterface; /* SDIO Standard Interface Code to match or CSR_SDIO_ANY_SDIO_INTERFACE */
+ 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;
/*----------------------------------------------------------------------------*
CsrSdioSuspendCallback suspend;
CsrSdioResumeCallback resume;
CsrSdioFunctionId *ids;
- CsrUint8 idsCount;
+ u8 idsCount;
void *priv; /* For use by the SDIO Driver */
} CsrSdioFunctionDriver;
* the callback function.
*
*----------------------------------------------------------------------------*/
-CsrResult CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data);
-CsrResult CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data);
-void CsrSdioRead8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data, CsrSdioAsyncCallback callback);
-void CsrSdioWrite8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data, CsrSdioAsyncCallback callback);
+CsrResult CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, u8 *data);
+CsrResult CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, u8 data);
+void CsrSdioRead8Async(CsrSdioFunction *function, CsrUint32 address, u8 *data, CsrSdioAsyncCallback callback);
+void CsrSdioWrite8Async(CsrSdioFunction *function, CsrUint32 address, u8 data, CsrSdioAsyncCallback callback);
/*----------------------------------------------------------------------------*
* NAME
* the callback function.
*
*----------------------------------------------------------------------------*/
-CsrResult CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data);
-CsrResult CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data);
-void CsrSdioF0Read8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data, CsrSdioAsyncCallback callback);
-void CsrSdioF0Write8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data, CsrSdioAsyncCallback callback);
+CsrResult CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, u8 *data);
+CsrResult CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, u8 data);
+void CsrSdioF0Read8Async(CsrSdioFunction *function, CsrUint32 address, u8 *data, CsrSdioAsyncCallback callback);
+void CsrSdioF0Write8Async(CsrSdioFunction *function, CsrUint32 address, u8 data, CsrSdioAsyncCallback callback);
/*----------------------------------------------------------------------------*
* NAME
#include "csr_pmem.h"
#include "csr_lib.h"
-void CsrUint8Des(CsrUint8 *value, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint8Des(u8 *value, u8 *buffer, CsrSize *offset)
{
*value = buffer[*offset];
*offset += sizeof(*value);
}
EXPORT_SYMBOL_GPL(CsrUint8Des);
-void CsrUint16Des(CsrUint16 *value, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint16Des(CsrUint16 *value, u8 *buffer, CsrSize *offset)
{
*value = (buffer[*offset + 0] << 0) |
(buffer[*offset + 1] << 8);
}
EXPORT_SYMBOL_GPL(CsrUint16Des);
-void CsrUint32Des(CsrUint32 *value, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint32Des(CsrUint32 *value, u8 *buffer, CsrSize *offset)
{
*value = (buffer[*offset + 0] << 0) |
(buffer[*offset + 1] << 8) |
}
EXPORT_SYMBOL_GPL(CsrUint32Des);
-void CsrMemCpyDes(void *value, CsrUint8 *buffer, CsrSize *offset, CsrSize length)
+void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length)
{
CsrMemCpy(value, &buffer[*offset], length);
*offset += length;
}
EXPORT_SYMBOL_GPL(CsrMemCpyDes);
-void CsrCharStringDes(CsrCharString **value, CsrUint8 *buffer, CsrSize *offset)
+void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset)
{
*value = CsrStrDup((CsrCharString *) &buffer[*offset]);
*offset += CsrStrLen(*value) + 1;
}
EXPORT_SYMBOL_GPL(CsrCharStringDes);
-void CsrUtf8StringDes(CsrUtf8String **value, CsrUint8 *buffer, CsrSize *offset)
+void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset)
{
*value = (CsrUtf8String *) CsrStrDup((CsrCharString *) &buffer[*offset]);
*offset += CsrStrLen((CsrCharString *) *value) + 1;
}
-void CsrUtf16StringDes(CsrUtf16String **value, CsrUint8 *buffer, CsrSize *offset)
+void CsrUtf16StringDes(CsrUtf16String **value, u8 *buffer, CsrSize *offset)
{
CsrUint32 length, i;
}
}
-void CsrSizeDes(CsrSize *value, CsrUint8 *buffer, CsrSize *offset)
+void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset)
{
*value = (buffer[*offset + 0] << 0) |
(buffer[*offset + 1] << 8) |
*offset += sizeof(*value);
}
-void CsrVoidPtrDes(void **value, CsrUint8 *buffer, CsrSize *offset)
+void CsrVoidPtrDes(void **value, u8 *buffer, CsrSize *offset)
{
CsrSizeDes((CsrSize *) value, buffer, offset);
}
-void CsrUint8Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint8 value)
+void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value)
{
buffer[*offset] = value;
*offset += sizeof(value);
}
EXPORT_SYMBOL_GPL(CsrUint8Ser);
-void CsrUint16Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint16 value)
+void CsrUint16Ser(u8 *buffer, CsrSize *offset, CsrUint16 value)
{
- buffer[*offset + 0] = (CsrUint8) ((value >> 0) & 0xFF);
- buffer[*offset + 1] = (CsrUint8) ((value >> 8) & 0xFF);
+ buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
+ buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
*offset += sizeof(value);
}
EXPORT_SYMBOL_GPL(CsrUint16Ser);
-void CsrUint32Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint32 value)
+void CsrUint32Ser(u8 *buffer, CsrSize *offset, CsrUint32 value)
{
- buffer[*offset + 0] = (CsrUint8) ((value >> 0) & 0xFF);
- buffer[*offset + 1] = (CsrUint8) ((value >> 8) & 0xFF);
- buffer[*offset + 2] = (CsrUint8) ((value >> 16) & 0xFF);
- buffer[*offset + 3] = (CsrUint8) ((value >> 24) & 0xFF);
+ buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
+ buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
+ buffer[*offset + 2] = (u8) ((value >> 16) & 0xFF);
+ buffer[*offset + 3] = (u8) ((value >> 24) & 0xFF);
*offset += sizeof(value);
}
EXPORT_SYMBOL_GPL(CsrUint32Ser);
-void CsrMemCpySer(CsrUint8 *buffer, CsrSize *offset, const void *value, CsrSize length)
+void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length)
{
CsrMemCpy(&buffer[*offset], value, length);
*offset += length;
}
EXPORT_SYMBOL_GPL(CsrMemCpySer);
-void CsrCharStringSer(CsrUint8 *buffer, CsrSize *offset, const CsrCharString *value)
+void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value)
{
if (value)
{
}
EXPORT_SYMBOL_GPL(CsrCharStringSer);
-void CsrUtf8StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf8String *value)
+void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value)
{
CsrCharStringSer(buffer, offset, (CsrCharString *) value);
}
-void CsrUtf16StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf16String *value)
+void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const CsrUtf16String *value)
{
if (value)
{
}
}
-void CsrSizeSer(CsrUint8 *buffer, CsrSize *offset, CsrSize value)
+void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value)
{
- buffer[*offset + 0] = (CsrUint8) ((value >> 0) & 0xFF);
- buffer[*offset + 1] = (CsrUint8) ((value >> 8) & 0xFF);
- buffer[*offset + 2] = (CsrUint8) ((value >> 16) & 0xFF);
- buffer[*offset + 3] = (CsrUint8) ((value >> 24) & 0xFF);
+ buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
+ buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
+ buffer[*offset + 2] = (u8) ((value >> 16) & 0xFF);
+ buffer[*offset + 3] = (u8) ((value >> 24) & 0xFF);
*offset += sizeof(value);
}
-void CsrVoidPtrSer(CsrUint8 *buffer, CsrSize *offset, void *ptr)
+void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr)
{
CsrSizeSer(buffer, offset, (CsrSize) ptr);
}
return 2;
}
-CsrUint8 *CsrEventSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrEvent *primitive = (CsrEvent *) msg;
*len = 0;
return ptr;
}
-void *CsrEventDes(CsrUint8 *buffer, CsrSize length)
+void *CsrEventDes(u8 *buffer, CsrSize length)
{
CsrEvent *primitive = (CsrEvent *) CsrPmemAlloc(sizeof(CsrEvent));
CsrSize offset = 0;
return 3;
}
-CsrUint8 *CsrEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) msg;
*len = 0;
return ptr;
}
-void *CsrEventCsrUint8Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint8Des(u8 *buffer, CsrSize length)
{
CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrEventCsrUint8));
return 4;
}
-CsrUint8 *CsrEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) msg;
*len = 0;
return ptr;
}
-void *CsrEventCsrUint16Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint16Des(u8 *buffer, CsrSize length)
{
CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16));
return 6;
}
-CsrUint8 *CsrEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) msg;
*len = 0;
return ptr;
}
-void *CsrEventCsrUint32Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint32Des(u8 *buffer, CsrSize length)
{
CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrEventCsrUint32));
return 5;
}
-CsrUint8 *CsrEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) msg;
*len = 0;
return ptr;
}
-void *CsrEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length)
{
CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint8));
return 6;
}
-CsrUint8 *CsrEventCsrUint16CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) msg;
*len = 0;
return ptr;
}
-void *CsrEventCsrUint16CsrUint16Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length)
{
CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint16));
return 8;
}
-CsrUint8 *CsrEventCsrUint16CsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) msg;
*len = 0;
return ptr;
}
-void *CsrEventCsrUint16CsrUint32Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length)
{
CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint32));
return 4 + CsrStrLen(primitive->value2) + 1;
}
-CsrUint8 *CsrEventCsrUint16CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
*len = 0;
return ptr;
}
-void *CsrEventCsrUint16CsrCharStringDes(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length)
{
CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrCharString));
return 8;
}
-CsrUint8 *CsrEventCsrUint32CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) msg;
*len = 0;
return ptr;
}
-void *CsrEventCsrUint32CsrUint16Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length)
{
CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint32CsrUint16));
return 6 + CsrStrLen(primitive->value2) + 1;
}
-CsrUint8 *CsrEventCsrUint32CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
*len = 0;
return ptr;
}
-void *CsrEventCsrUint32CsrCharStringDes(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, CsrSize length)
{
CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) CsrPmemAlloc(sizeof(CsrEventCsrUint32CsrCharString));
typedef ptrdiff_t CsrIntptr; /* intptr_t is not defined in kernel. Use the equivalent ptrdiff_t. */
/* Unsigned fixed width types */
-typedef uint8_t CsrUint8;
typedef uint16_t CsrUint16;
typedef uint32_t CsrUint32;
typedef int32_t CsrInt32;
/* Boolean */
-typedef CsrUint8 CsrBool;
+typedef u8 CsrBool;
/* String types */
typedef char CsrCharString;
-typedef CsrUint8 CsrUtf8String;
+typedef u8 CsrUtf8String;
typedef CsrUint16 CsrUtf16String; /* 16-bit UTF16 strings */
typedef CsrUint32 CsrUint24;
*
* D-13157
*/
-typedef CsrUint8 CsrUcs2String;
+typedef u8 CsrUcs2String;
CsrSize CsrUcs2ByteStrLen(const CsrUcs2String *ucs2String);
CsrSize CsrConverterUcs2ByteStrLen(const CsrUcs2String *str);
-CsrUint8 *CsrUcs2ByteString2Utf8(const CsrUcs2String *ucs2String);
-CsrUcs2String *CsrUtf82Ucs2ByteString(const CsrUint8 *utf8String);
+u8 *CsrUcs2ByteString2Utf8(const CsrUcs2String *ucs2String);
+CsrUcs2String *CsrUtf82Ucs2ByteString(const u8 *utf8String);
-CsrUint8 *CsrUtf16String2Ucs2ByteString(const CsrUtf16String *source);
-CsrUtf16String *CsrUcs2ByteString2Utf16String(const CsrUint8 *source);
+u8 *CsrUtf16String2Ucs2ByteString(const CsrUtf16String *source);
+CsrUtf16String *CsrUcs2ByteString2Utf16String(const u8 *source);
#ifdef __cplusplus
}
#define UNI_SUR_LOW_START ((CsrUint32) 0xDC00)
#define UNI_SUR_LOW_END ((CsrUint32) 0xDFFF)
#define UNI_REPLACEMENT_CHAR ((CsrUint32) 0xFFFD)
-#define UNI_HALF_SHIFT ((CsrUint8) 10) /* used for shifting by 10 bits */
+#define UNI_HALF_SHIFT ((u8) 10) /* used for shifting by 10 bits */
#define UNI_HALF_BASE ((CsrUint32) 0x00010000)
#define UNI_BYTEMASK ((CsrUint32) 0xBF)
#define UNI_BYTEMARK ((CsrUint32) 0x80)
*********************************************************************************/
CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, CsrUint32 count)
{
- return CsrMemCpy((CsrUint8 *) dest, (CsrUint8 *) src, count * sizeof(CsrUtf16String));
+ return CsrMemCpy((u8 *) dest, (u8 *) src, count * sizeof(CsrUtf16String));
}
/********************************************************************************
CsrUint32 ch;
CsrUint32 length;
CsrUint32 sourceLength;
- CsrUint8 bytes;
+ u8 bytes;
CsrBool appendNull = FALSE;
- CsrUint8 firstByteMark[5] = {0x00, 0x00, 0xC0, 0xE0, 0xF0};
+ u8 firstByteMark[5] = {0x00, 0x00, 0xC0, 0xE0, 0xF0};
if (!source)
{
{
case 4:
{
- *--dest = (CsrUint8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
+ *--dest = (u8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
ch >>= 6;
}
/* FALLTHROUGH */
case 3:
{
- *--dest = (CsrUint8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
+ *--dest = (u8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
ch >>= 6;
}
/* FALLTHROUGH */
case 2:
{
- *--dest = (CsrUint8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
+ *--dest = (u8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
ch >>= 6;
}
/* FALLTHROUGH */
case 1:
{
- *--dest = (CsrUint8) (ch | firstByteMark[bytes]);
+ *--dest = (u8) (ch | firstByteMark[bytes]);
}
/* FALLTHROUGH */
default:
static CsrBool isLegalUtf8(const CsrUtf8String *codeUnit, CsrUint32 length)
{
const CsrUtf8String *srcPtr = codeUnit + length;
- CsrUint8 byte;
+ u8 byte;
switch (length) /* Everything falls through except case 1 */
{
/*------------------------------------------------------------------*/
/* Time proportional with the number of 1's */
-CsrUint8 CsrBitCountSparse(CsrUint32 n)
+u8 CsrBitCountSparse(CsrUint32 n)
{
- CsrUint8 count = 0;
+ u8 count = 0;
while (n)
{
}
/* Time proportional with the number of 0's */
-CsrUint8 CsrBitCountDense(CsrUint32 n)
+u8 CsrBitCountDense(CsrUint32 n)
{
- CsrUint8 count = 8 * sizeof(CsrUint32);
+ u8 count = 8 * sizeof(CsrUint32);
n ^= (CsrUint32) (-1);
/*------------------------------------------------------------------*/
/* Base conversion */
/*------------------------------------------------------------------*/
-CsrBool CsrHexStrToUint8(const CsrCharString *string, CsrUint8 *returnValue)
+CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue)
{
CsrUint16 currentIndex = 0;
*returnValue = 0;
{
while (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
{
- *returnValue = (CsrUint8) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
+ *returnValue = (u8) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
currentIndex++;
if (currentIndex >= 2)
{
void CsrIntToBase10(CsrInt32 number, CsrCharString *str)
{
CsrInt32 digit;
- CsrUint8 index;
+ u8 index;
CsrCharString res[I2B10_MAX];
CsrBool foundDigit = FALSE;
}
EXPORT_SYMBOL_GPL(CsrMemCpy);
-void *CsrMemSet(void *dest, CsrUint8 c, CsrSize count)
+void *CsrMemSet(void *dest, u8 c, CsrSize count)
{
return memset(dest, c, count);
}
/*------------------------------------------------------------------*/
/* Misc */
/*------------------------------------------------------------------*/
-CsrBool CsrIsSpace(CsrUint8 c)
+CsrBool CsrIsSpace(u8 c)
{
switch (c)
{
/*------------------------------------------------------------------*/
/* Bits - intended to operate on CsrUint32 values */
/*------------------------------------------------------------------*/
-CsrUint8 CsrBitCountSparse(CsrUint32 n);
-CsrUint8 CsrBitCountDense(CsrUint32 n);
+u8 CsrBitCountSparse(CsrUint32 n);
+u8 CsrBitCountDense(CsrUint32 n);
/*------------------------------------------------------------------*/
/* Base conversion */
/*------------------------------------------------------------------*/
-CsrBool CsrHexStrToUint8(const CsrCharString *string, CsrUint8 *returnValue);
+CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue);
CsrBool CsrHexStrToUint16(const CsrCharString *string, CsrUint16 *returnValue);
CsrBool CsrHexStrToUint32(const CsrCharString *string, CsrUint32 *returnValue);
CsrUint32 CsrPow(CsrUint32 base, CsrUint32 exponent);
CsrInt32 CsrStrNCmp(const CsrCharString *string1, const CsrCharString *string2, CsrSize count);
CsrCharString *CsrStrChr(const CsrCharString *string, CsrCharString c);
CsrCharString *CsrStrStr(const CsrCharString *string1, const CsrCharString *string2);
-void *CsrMemSet(void *dest, CsrUint8 c, CsrSize count);
+void *CsrMemSet(void *dest, u8 c, CsrSize count);
CsrSize CsrStrLen(const CsrCharString *string);
#endif /* !CSR_USE_STDC_LIB */
CsrInt32 CsrVsnprintf(CsrCharString *string, CsrSize count, const CsrCharString *format, va_list args);
/*------------------------------------------------------------------*/
/* Misc */
/*------------------------------------------------------------------*/
-CsrBool CsrIsSpace(CsrUint8 c);
+CsrBool CsrIsSpace(u8 c);
#define CsrOffsetOf(st, m) ((CsrSize) & ((st *) 0)->m)
#ifdef __cplusplus
/* MAC address */
typedef struct
{
- CsrUint8 a[6];
+ u8 a[6];
} CsrWifiMacAddress;
/* IPv4 address */
typedef struct
{
- CsrUint8 a[4];
+ u8 a[4];
} CsrWifiIp4Address;
/* IPv6 address */
typedef struct
{
- CsrUint8 a[16];
+ u8 a[16];
} CsrWifiIp6Address;
typedef struct
{
- CsrUint8 ssid[32];
- CsrUint8 length;
+ u8 ssid[32];
+ u8 length;
} CsrWifiSsid;
/*******************************************************************************
*/
typedef struct
{
- const CsrUint8 numEntries;
+ const u8 numEntries;
const CsrBool saveAll;
const CsrWifiFsmEventEntry *eventEntryArray; /* array of transition function pointers for state */
#ifdef CSR_LOG_ENABLE
CsrResult unifi_dl_firmware(card_t *card, void *arg);
CsrResult unifi_dl_patch(card_t *card, void *arg, CsrUint32 boot_ctrl);
-CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, CsrUint8 opcode);
+CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, u8 opcode);
void* unifi_dl_fw_read_start(card_t *card, CsrInt8 is_fw);
CsrResult unifi_coredump_handle_request(card_t *card);
{
CsrUint32 val = 0x01234567;
- if (*((CsrUint8 *)&val) == 0x01)
+ if (*((u8 *)&val) == 0x01)
{
card->lsb = sizeof(void *) - 1; /* BE */
}
* ---------------------------------------------------------------------------
*/
static void _build_sdio_config_data(sdio_config_data_t *cfg_data,
- const CsrUint8 *cfg_data_buf)
+ const u8 *cfg_data_buf)
{
CsrInt16 offset = 0;
CsrUint16 finger_print;
symbol_t slut;
sdio_config_data_t *cfg_data;
- CsrUint8 cfg_data_buf[SDIO_CONFIG_DATA_SIZE];
+ u8 cfg_data_buf[SDIO_CONFIG_DATA_SIZE];
CsrResult r;
void *dlpriv;
CsrInt16 major, minor;
{
CsrInt16 i;
CsrResult r;
- CsrUint8 io_enable;
+ u8 io_enable;
CsrResult csrResult;
func_enter();
{
CsrInt16 i;
CsrResult r;
- CsrUint8 io_enable;
+ u8 io_enable;
CsrResult csrResult;
func_enter();
static CsrResult card_init_slots(card_t *card)
{
CsrResult r;
- CsrUint8 i;
+ u8 i;
func_enter();
static void CardReassignDynamicReservation(card_t *card)
{
- CsrUint8 i;
+ u8 i;
func_enter();
*/
void CardClearFromHostDataSlot(card_t *card, const CsrInt16 slot)
{
- CsrUint8 queue = card->from_host_data[slot].queue;
+ u8 queue = card->from_host_data[slot].queue;
const void *os_data_ptr = card->from_host_data[slot].bd.os_data_ptr;
func_enter();
*/
void CardClearFromHostDataSlotWithoutFreeingBulkData(card_t *card, const CsrInt16 slot)
{
- CsrUint8 queue = card->from_host_data[slot].queue;
+ u8 queue = card->from_host_data[slot].queue;
/* Initialise the from_host data slot so it can be re-used,
* Set length field in from_host_data array to 0.
* Setup the chip helper so that we can access the registers (and
* also tell what sub-type of HIP we should use).
*/
- card->helper = ChipHelper_GetVersionSdio((CsrUint8)card->chip_id);
+ card->helper = ChipHelper_GetVersionSdio((u8)card->chip_id);
if (!card->helper)
{
unifi_error(card->ospriv, "Null ChipHelper\n");
if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
{
r = sdio_write_f0(card, SDIO_CSR_FROM_HOST_SCRATCH0,
- (CsrUint8)card->unifi_interrupt_seq);
+ (u8)card->unifi_interrupt_seq);
}
else
{
r = unifi_write_direct_8_or_16(card,
ChipHelper_SHARED_IO_INTERRUPT(card->helper) * 2,
- (CsrUint8)card->unifi_interrupt_seq);
+ (u8)card->unifi_interrupt_seq);
}
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
{
CsrResult CardEnableInt(card_t *card)
{
CsrResult r;
- CsrUint8 int_enable;
+ u8 int_enable;
r = sdio_read_f0(card, SDIO_INT_ENABLE, &int_enable);
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
CsrResult CardDisableInt(card_t *card)
{
CsrResult r;
- CsrUint8 int_enable;
+ u8 int_enable;
r = sdio_read_f0(card, SDIO_INT_ENABLE, &int_enable);
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
CsrResult CardPendingInt(card_t *card, CsrBool *pintr)
{
CsrResult r;
- CsrUint8 pending;
+ u8 pending;
*pintr = FALSE;
CsrResult CardIntEnabled(card_t *card, CsrBool *enabled)
{
CsrResult r;
- CsrUint8 int_enable;
+ u8 int_enable;
r = sdio_read_f0(card, SDIO_INT_ENABLE, &int_enable);
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
CsrResult CardWriteBulkData(card_t *card, card_signal_t *csptr, unifi_TrafficQueue queue)
{
CsrUint16 i, slots[UNIFI_MAX_DATA_REFERENCES], j = 0;
- CsrUint8 *packed_sigptr, num_slots_required = 0;
+ u8 *packed_sigptr, num_slots_required = 0;
bulk_data_desc_t *bulkdata = csptr->bulkdata;
CsrInt16 h, nslots;
CsrResult unifi_card_stop_processor(card_t *card, enum unifi_dbg_processors_select which)
{
CsrResult r = CSR_RESULT_SUCCESS;
- CsrUint8 status;
+ u8 status;
CsrInt16 retry = 100;
while (retry--)
static const CsrCharString *const states[] = {
"AWAKE", "DROWSY", "TORPID"
};
- static const CsrUint8 state_csr_host_wakeup[] = {
+ static const u8 state_csr_host_wakeup[] = {
1, 3, 0
};
- static const CsrUint8 state_io_abort[] = {
+ static const u8 state_io_abort[] = {
0, 2, 3
};
if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
{
r = sdio_write_f0(card, SDIO_CSR_HOST_WAKEUP,
- (CsrUint8)((card->function << 4) | state_csr_host_wakeup[state]));
+ (u8)((card->function << 4) | state_csr_host_wakeup[state]));
}
else
{
*/
CsrResult unifi_check_io_status(card_t *card, CsrInt32 *status)
{
- CsrUint8 io_en;
+ u8 io_en;
CsrResult r;
CsrBool pending;
*/
typedef struct card_signal
{
- CsrUint8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
+ u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
/* Length of the SIGNAL inside sigbuf */
CsrUint16 signal_length;
CsrUint16 chip_version;
/* From the SDIO driver (probably 1) */
- CsrUint8 function;
+ u8 function;
/* This is sused to get the register addresses and things. */
ChipDescript *helper;
/* UDI callback for logging UniFi interactions */
udi_func_t udi_hook;
- CsrUint8 bh_reason_host;
- CsrUint8 bh_reason_unifi;
+ u8 bh_reason_host;
+ u8 bh_reason_unifi;
/* SDIO clock speed request from OS layer */
- CsrUint8 request_max_clock;
+ u8 request_max_clock;
/* Last SDIO clock frequency set */
CsrUint32 sdio_clock_speed;
#define UNIFI_FH_BUF_SIZE 1024
struct sigbuf
{
- CsrUint8 *buf; /* buffer area */
- CsrUint8 *ptr; /* current pos */
+ u8 *buf; /* buffer area */
+ u8 *ptr; /* current pos */
CsrUint16 count; /* signal count */
CsrUint16 bufsize;
} fh_buffer;
* Flag to say we need to generate an interrupt at end of processing.
*/
CsrUint32 unifi_interrupt_seq;
- CsrUint8 generate_interrupt;
+ u8 generate_interrupt;
/* Pointers to the bulk data slots */
CsrUint32 sdio_bytes_read;
CsrUint32 sdio_bytes_written;
- CsrUint8 memory_resources_allocated;
+ u8 memory_resources_allocated;
/* UniFi SDIO I/O Block size. */
CsrUint16 sdio_io_block_size;
CsrUint32 intmode;
#ifdef UNIFI_DEBUG
- CsrUint8 lsb;
+ u8 lsb;
#endif
/* Historic firmware panic codes */
#define UNIFI_SDIO_READ 0
#define UNIFI_SDIO_WRITE 1
-CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 *pdata);
-CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 data);
-CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 *pdata);
-CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 data);
+CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 *pdata);
+CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 data);
+CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, u8 *pdata);
+CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, u8 data);
CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, CsrUint16 *pdata);
CsrResult unifi_read_direct32(card_t *card, CsrUint32 addr, CsrUint32 *pdata);
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 sdio_read_f0(card_t *card, CsrUint32 addr, CsrUint8 *pdata);
-CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, CsrUint8 data);
+CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, u8 *pdata);
+CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, u8 data);
void unifi_read_panic(card_t *card);
#ifdef CSR_PRE_ALLOC_NET_DATA
static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed);
static CsrResult process_bulk_data_command(card_t *card,
- const CsrUint8 *cmdptr,
+ const u8 *cmdptr,
CsrInt16 cmd, CsrUint16 len);
static CsrResult process_clear_slot_command(card_t *card,
- const CsrUint8 *cmdptr);
+ const u8 *cmdptr);
static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed);
static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed);
static void restart_packet_flow(card_t *card);
*/
if (card->host_state == UNIFI_HOST_STATE_DROWSY || card->host_state == UNIFI_HOST_STATE_TORPID)
{
- CsrUint8 reason_unifi;
+ u8 reason_unifi;
/*
* An interrupt may occur while or after we cache the reason.
/* Update the count of signals read */
r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 6,
- (CsrUint8)card->to_host_signals_r);
+ (u8)card->to_host_signals_r);
if (r != CSR_RESULT_SUCCESS)
{
unifi_error(card->ospriv, "Failed to update to-host signals read\n");
* None.
* ---------------------------------------------------------------------------
*/
-static void read_unpack_cmd(const CsrUint8 *ptr, bulk_data_cmd_t *bulk_data_cmd)
+static void read_unpack_cmd(const u8 *ptr, bulk_data_cmd_t *bulk_data_cmd)
{
CsrInt16 index = 0;
bulk_data_cmd->cmd_and_len = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
{
CsrInt16 pending;
CsrInt16 remaining;
- CsrUint8 *bufptr;
+ u8 *bufptr;
bulk_data_param_t data_ptrs;
CsrInt16 cmd;
CsrUint16 sig_len;
if (remaining > 0)
{
/* Use a safe copy because source and destination may overlap */
- CsrUint8 *d = card->th_buffer.buf;
- CsrUint8 *s = bufptr;
+ u8 *d = card->th_buffer.buf;
+ u8 *s = bufptr;
CsrInt32 n = remaining;
while (n--)
{
* 0 on success, CSR error code on error
* ---------------------------------------------------------------------------
*/
-static CsrResult process_clear_slot_command(card_t *card, const CsrUint8 *cmdptr)
+static CsrResult process_clear_slot_command(card_t *card, const u8 *cmdptr)
{
CsrUint16 data_slot;
CsrInt16 slot;
* CSR_RESULT_SUCCESS on success, CSR error code on error
* ---------------------------------------------------------------------------
*/
-static CsrResult process_bulk_data_command(card_t *card, const CsrUint8 *cmdptr,
+static CsrResult process_bulk_data_command(card_t *card, const u8 *cmdptr,
CsrInt16 cmd, CsrUint16 len)
{
bulk_data_desc_t *bdslot;
#ifdef CSR_WIFI_ALIGNMENT_WORKAROUND
- CsrUint8 *host_bulk_data_slot;
+ u8 *host_bulk_data_slot;
#endif
bulk_data_cmd_t bdcmd;
CsrInt16 offset;
CsrInt16 i;
CsrUint16 sig_chunks, total_length, free_chunks_in_fh_buffer;
bulk_data_param_t bulkdata;
- CsrUint8 *packed_sigptr;
+ u8 *packed_sigptr;
CsrUint16 signal_length = 0;
/* Retrieve the entry at the head of the queue */
/* Append packed signal to F-H buffer */
total_length = sig_chunks * card->config_data.sig_frag_size;
- card->fh_buffer.ptr[0] = (CsrUint8)(signal_length & 0xff);
+ card->fh_buffer.ptr[0] = (u8)(signal_length & 0xff);
card->fh_buffer.ptr[1] =
- (CsrUint8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
+ (u8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
CsrMemCpy(card->fh_buffer.ptr + 2, packed_sigptr, signal_length);
CsrMemSet(card->fh_buffer.ptr + 2 + signal_length, 0,
card_signal_t *csptr;
CsrUint16 sig_chunks, total_length, free_chunks_in_fh_buffer;
bulk_data_param_t bulkdata;
- CsrUint8 *packed_sigptr;
+ u8 *packed_sigptr;
CsrUint16 signal_length = 0;
/* if this queue is empty go to next one. */
/* Append packed signal to F-H buffer */
total_length = sig_chunks * card->config_data.sig_frag_size;
- card->fh_buffer.ptr[0] = (CsrUint8)(signal_length & 0xff);
+ card->fh_buffer.ptr[0] = (u8)(signal_length & 0xff);
card->fh_buffer.ptr[1] =
- (CsrUint8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
+ (u8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
CsrMemCpy(card->fh_buffer.ptr + 2, packed_sigptr, signal_length);
CsrMemSet(card->fh_buffer.ptr + 2 + signal_length, 0,
card->from_host_signals_w =
(card->from_host_signals_w + card->fh_buffer.count) % 128u;
r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 0,
- (CsrUint8)card->from_host_signals_w);
+ (u8)card->from_host_signals_w);
if (r != CSR_RESULT_SUCCESS)
{
unifi_error(card->ospriv, "Failed to write fh signal count %u with error %d\n",
*/
static void restart_packet_flow(card_t *card)
{
- CsrUint8 q;
+ u8 q;
/*
* We only look at the fh_traffic_queue, because that is where packets from
* CSR_RESULT_FAILURE an SDIO error occurred
* ---------------------------------------------------------------------------
*/
-static CsrResult retrying_read8(card_t *card, CsrInt16 funcnum, CsrUint32 addr, CsrUint8 *pdata)
+static CsrResult retrying_read8(card_t *card, CsrInt16 funcnum, CsrUint32 addr, u8 *pdata)
{
CsrSdioFunction *sdio = card->sdio_if;
CsrResult r = CSR_RESULT_SUCCESS;
} /* retrying_read8() */
-static CsrResult retrying_write8(card_t *card, CsrInt16 funcnum, CsrUint32 addr, CsrUint8 data)
+static CsrResult retrying_write8(card_t *card, CsrInt16 funcnum, CsrUint32 addr, u8 data)
{
CsrSdioFunction *sdio = card->sdio_if;
CsrResult r = CSR_RESULT_SUCCESS;
* CSR_RESULT_FAILURE an SDIO error occurred
* ---------------------------------------------------------------------------
*/
-CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, CsrUint8 *pdata)
+CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, u8 *pdata)
{
#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
card->cmd_prof.cmd52_f0_r_count++;
* CSR_RESULT_FAILURE an SDIO error occurred
* ---------------------------------------------------------------------------
*/
-CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, CsrUint8 data)
+CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, u8 data)
{
#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
card->cmd_prof.cmd52_f0_w_count++;
* CSR_RESULT_SUCCESS on success, non-zero error code on error:
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 *pdata)
+CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, u8 *pdata)
{
#ifdef CSR_WIFI_TRANSPORT_CSPI
CsrUint16 w;
CsrResult r;
r = retrying_read16(card, card->function, addr, &w);
- *pdata = (CsrUint8)(w & 0xFF);
+ *pdata = (u8)(w & 0xFF);
return r;
#else
return retrying_read8(card, card->function, addr, pdata);
* to memory until the preceding even address is written.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 data)
+CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, u8 data)
{
if (addr & 1)
{
{
CsrResult r;
CsrUint32 i;
- CsrUint8 *cptr;
+ u8 *cptr;
CsrUint16 w;
*num = 0;
- cptr = (CsrUint8 *)pdata;
+ cptr = (u8 *)pdata;
for (i = 0; i < len; i += 2)
{
r = retrying_read16(card, card->function, addr, &w);
return r;
}
- *cptr++ = ((CsrUint8)w & 0xFF);
+ *cptr++ = ((u8)w & 0xFF);
if ((m >= 0) && (((CsrInt8)w & 0xFF) == m))
{
break;
break;
}
- *cptr++ = ((CsrUint8)(w >> 8) & 0xFF);
+ *cptr++ = ((u8)(w >> 8) & 0xFF);
if ((m >= 0) && (((CsrInt8)(w >> 8) & 0xFF) == m))
{
break;
addr += 2;
}
- *num = (CsrInt32)(cptr - (CsrUint8 *)pdata);
+ *num = (CsrInt32)(cptr - (u8 *)pdata);
return CSR_RESULT_SUCCESS;
}
CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len)
{
CsrResult r;
- CsrUint8 *cptr;
+ u8 *cptr;
CsrInt16 signed_len;
- cptr = (CsrUint8 *)pdata;
+ cptr = (u8 *)pdata;
signed_len = (CsrInt16)len;
while (signed_len > 0)
{
{
r = unifi_write_direct16(card,
ChipHelper_DBG_HOST_PROC_SELECT(card->helper) * 2,
- (CsrUint8)select);
+ (u8)select);
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
{
return r;
* CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 *pdata)
+CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 *pdata)
{
CsrUint32 sdio_addr;
CsrResult r;
#endif
#ifdef CSR_WIFI_TRANSPORT_CSPI
r = retrying_read16(card, card->function, sdio_addr, &w);
- *pdata = (CsrUint8)(w & 0xFF);
+ *pdata = (u8)(w & 0xFF);
return r;
#else
return retrying_read8(card, card->function, sdio_addr, pdata);
* write with the previously cached odd byte.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 data)
+CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 data)
{
CsrUint32 sdio_addr;
CsrResult r;
*/
CsrInt32 unifi_read_shared_count(card_t *card, CsrUint32 addr)
{
- CsrUint8 b;
+ u8 b;
/* I've increased this count, because I have seen cases where
* there were three reads in a row with the top bit set. I'm not
* sure why this might have happened, but I can't see a problem
static CsrResult csr_sdio_block_rw(card_t *card, CsrInt16 funcnum,
- CsrUint32 addr, CsrUint8 *pdata,
+ CsrUint32 addr, u8 *pdata,
CsrUint16 count, CsrInt16 dir_is_write)
{
CsrResult csrResult;
CsrResult r = CSR_RESULT_SUCCESS; /* HIP error code */
CsrInt16 retries = CMD53_RETRIES;
CsrInt16 stat_retries;
- CsrUint8 stat;
+ u8 stat;
CsrInt16 dump_read;
#ifdef UNIFI_DEBUG
- CsrUint8 *pdata_lsb = ((CsrUint8 *)&pdata) + card->lsb;
+ u8 *pdata_lsb = ((u8 *)&pdata) + card->lsb;
#endif
#ifdef CSR_WIFI_MAKE_FAKE_CMD53_ERRORS
static CsrInt16 fake_error;
while (1)
{
csrResult = csr_sdio_block_rw(card, card->function, handle,
- (CsrUint8 *)pdata, (CsrUint16)len,
+ (u8 *)pdata, (CsrUint16)len,
direction);
if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
{
/* The transfer failed, rewind and try again */
r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 8,
- (CsrUint8)(handle & 0xff));
+ (u8)(handle & 0xff));
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
{
return r;
CsrResult csrResult;
csrResult = csr_sdio_block_rw(card, card->function, handle,
- (CsrUint8 *)pdata, (CsrUint16)len, direction);
+ (u8 *)pdata, (CsrUint16)len, direction);
if (csrResult != CSR_RESULT_SUCCESS)
{
unifi_error(card->ospriv, "Block %s failed\n",
&hyd_wlan_subsys_desc_v1
};
-ChipDescript* ChipHelper_GetVersionSdio(CsrUint8 sdio_ver)
+ChipDescript* ChipHelper_GetVersionSdio(u8 sdio_ver)
{
CsrUint32 i;
/* This gets the version from the SDIO device id. This only
gives quite a coarse grained version, so we should update once
we hav access to the function N registers. */
-ChipDescript* ChipHelper_GetVersionSdio(CsrUint8 sdio_version);
+ChipDescript* ChipHelper_GetVersionSdio(u8 sdio_version);
/* The chip is some sort of BlueCore. If "age" is "pre_bc7" then
"version" is what was read from FF9A. If "age" is bc7_or_later
void GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81);
void GetVersionUniFi(CsrUint16 version);
void GetVersionBlueCore(chip_helper_bluecore_age age, CsrUint16 version);
- void GetVersionSdio(CsrUint8 sdio_version);
+ void GetVersionSdio(u8 sdio_version);
/* Helpers to build the definitions of the member functions. */
#define CHIP_HELPER_DEF0_CPP_DEC(ret_type, name, info) \
CsrInt32 pre_bc7;
CsrUint16 mask;
CsrUint16 result;
- CsrUint8 sdio;
+ u8 sdio;
};
struct chip_device_desc_t
CSR_GET_UINT16_FROM_LITTLE_ENDIAN(((_buf) + SIZEOF_SIGNAL_HEADER + UNIFI_MAX_DATA_REFERENCES * SIZEOF_DATAREF + 2))
-CsrInt32 get_packed_struct_size(const CsrUint8 *buf);
-CsrResult read_unpack_signal(const CsrUint8 *ptr, CSR_SIGNAL *sig);
-CsrResult write_pack(const CSR_SIGNAL *sig, CsrUint8 *ptr, CsrUint16 *sig_len);
+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);
#ifdef __cplusplus
}
* CSR_RESULT_SUCCESS on success, CSR error code on failure
* ---------------------------------------------------------------------------
*/
-static CsrResult safe_read_shared_location(card_t *card, CsrUint32 address, CsrUint8 *pdata)
+static CsrResult safe_read_shared_location(card_t *card, CsrUint32 address, u8 *pdata)
{
CsrResult r;
CsrUint16 limit = 1000;
- CsrUint8 b, b2;
+ u8 b, b2;
*pdata = 0;
#define OPERATION_TIMEOUT_LOOPS (100) /* when OPERATION_TIMEOUT_DELAY==1, (500) otherwise */
#define OPERATION_TIMEOUT_DELAY 1 /* msec, or 200usecs */
-CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, CsrUint8 opcode)
+CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, u8 opcode)
{
CsrResult r;
CsrInt16 op_retries;
r = CSR_RESULT_SUCCESS;
while (1)
{
- CsrUint8 op;
+ u8 op;
/*
* Read the memory location until two successive reads give
CsrUint32 op_addr)
{
CsrUint32 offset;
- CsrUint8 *buf;
+ u8 *buf;
CsrInt32 data_len;
CsrUint32 write_len;
CsrResult r;
* This is useful for stepping past the signal to the object in the buffer.
* ---------------------------------------------------------------------------
*/
-CsrInt32 get_packed_struct_size(const CsrUint8 *buf)
+CsrInt32 get_packed_struct_size(const u8 *buf)
{
CsrInt32 size = 0;
CsrUint16 sig_id;
* CSR_WIFI_HIP_RESULT_INVALID_VALUE if the ID of signal was not recognised.
* ---------------------------------------------------------------------------
*/
-CsrResult read_unpack_signal(const CsrUint8 *ptr, CSR_SIGNAL *sig)
+CsrResult read_unpack_signal(const u8 *ptr, CSR_SIGNAL *sig)
{
CsrInt32 index = 0;
* CSR_WIFI_HIP_RESULT_INVALID_VALUE if the ID of signal was not recognised.
* ---------------------------------------------------------------------------
*/
-CsrResult write_pack(const CSR_SIGNAL *sig, CsrUint8 *ptr, CsrUint16 *sig_len)
+CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, CsrUint16 *sig_len)
{
CsrInt16 index = 0;
* Calls unifi_pause_xmit() when the last slots are used.
* ---------------------------------------------------------------------------
*/
-static CsrResult send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 siglen,
+static CsrResult send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
const bulk_data_param_t *bulkdata,
q_t *sigq, CsrUint32 priority_q, CsrUint32 run_bh)
{
debug_print++;
}
/* Store the bulk data info in the soft queue. */
- csptr->bulkdata[i].os_data_ptr = (CsrUint8 *)bulkdata->d[i].os_data_ptr;
- csptr->bulkdata[i].os_net_buf_ptr = (CsrUint8 *)bulkdata->d[i].os_net_buf_ptr;
+ csptr->bulkdata[i].os_data_ptr = (u8 *)bulkdata->d[i].os_data_ptr;
+ csptr->bulkdata[i].os_net_buf_ptr = (u8 *)bulkdata->d[i].os_net_buf_ptr;
csptr->bulkdata[i].net_buf_length = bulkdata->d[i].net_buf_length;
csptr->bulkdata[i].data_length = datalen;
}
if (debug_print)
{
- const CsrUint8 *sig = sigptr;
+ const u8 *sig = sigptr;
unifi_error(card->ospriv, "Signal(%d): %02x %02x %02x %02x %02x %02x %02x %02x"
" %02x %02x %02x %02x %02x %02x %02x %02x\n",
* to the device. Signals are constructed using the UniFi packed structures.
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 siglen,
+CsrResult unifi_send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
const bulk_data_param_t *bulkdata)
{
q_t *sig_soft_q;
* Notes:
* ---------------------------------------------------------------------------
*/
-CsrResult unifi_send_resources_available(card_t *card, const CsrUint8 *sigptr)
+CsrResult unifi_send_resources_available(card_t *card, const u8 *sigptr)
{
q_t *sig_soft_q;
CsrUint16 signal_id = GET_SIGNAL_ID(sigptr);
typedef struct CSR_MAC_ADDRESS
{
- CsrUint8 x[6];
+ u8 x[6];
} CSR_MACADDRESS;
typedef enum CSR_MIB_STATUS
typedef struct CSR_TSF_TIME
{
- CsrUint8 x[8];
+ u8 x[8];
} CSR_TSF_TIME;
typedef CsrUint16 CSR_TIME_UNITS;
#define snap_802_2 0xAAAA0300
#define oui_rfc1042 0x00000000
#define oui_8021h 0x0000f800
-static const CsrUint8 aironet_snap[5] = { 0x00, 0x40, 0x96, 0x00, 0x00 };
+static const u8 aironet_snap[5] = { 0x00, 0x40, 0x96, 0x00, 0x00 };
/*
*/
static enum ta_frame_identity ta_detect_protocol(card_t *card, CsrWifiRouterCtrlProtocolDirection direction,
const bulk_data_desc_t *data,
- const CsrUint8 *saddr,
- const CsrUint8 *sta_macaddr)
+ const u8 *saddr,
+ const u8 *sta_macaddr)
{
ta_data_t *tad = &card->ta_sampling;
CsrUint16 proto;
if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
{
ta_l4stats_t *ta_l4stats = &tad->ta_l4stats;
- CsrUint8 l4proto = data->os_data_ptr[TA_IP_TYPE_OFFSET];
+ u8 l4proto = data->os_data_ptr[TA_IP_TYPE_OFFSET];
if (l4proto == TA_IP_TYPE_TCP)
{
void unifi_ta_sample(card_t *card,
CsrWifiRouterCtrlProtocolDirection direction,
const bulk_data_desc_t *data,
- const CsrUint8 *saddr,
- const CsrUint8 *sta_macaddr,
+ const u8 *saddr,
+ const u8 *sta_macaddr,
CsrUint32 timestamp,
CsrUint16 rate)
{
"AWAKE", "DROWSY", "TORPID"
};
#define SHARED_READ_RETRY_LIMIT 10
- CsrUint8 b;
+ u8 b;
#endif
if (remaining <= 0)
*/
typedef struct _bulk_data_desc
{
- const CsrUint8 *os_data_ptr;
+ const u8 *os_data_ptr;
CsrUint32 data_length;
const void *os_net_buf_ptr;
CsrUint32 net_buf_length;
*
* @ingroup upperedge
*/
-CsrResult unifi_send_signal(card_t *card, const CsrUint8 *sigptr,
+CsrResult unifi_send_signal(card_t *card, const u8 *sigptr,
CsrUint32 siglen,
const bulk_data_param_t *bulkdata);
*
* @ingroup upperedge
*/
-CsrResult unifi_send_resources_available(card_t *card, const CsrUint8 *sigptr);
+CsrResult unifi_send_resources_available(card_t *card, const u8 *sigptr);
/**
*
void unifi_ta_sample(card_t *card,
CsrWifiRouterCtrlProtocolDirection direction,
const bulk_data_desc_t *data,
- const CsrUint8 *saddr,
- const CsrUint8 *sta_macaddr,
+ const u8 *saddr,
+ const u8 *sta_macaddr,
CsrUint32 timestamp,
CsrUint16 rate);
* @ingroup upperedge
*/
void unifi_receive_event(void *ospriv,
- CsrUint8 *sigdata, CsrUint32 siglen,
+ u8 *sigdata, CsrUint32 siglen,
const bulk_data_param_t *bulkdata);
#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
UDI_LOG_TO_HOST = 0x0001
};
-typedef void (*udi_func_t)(void *ospriv, CsrUint8 *sigdata,
+typedef void (*udi_func_t)(void *ospriv, u8 *sigdata,
CsrUint32 signal_len,
const bulk_data_param_t *bulkdata,
enum udi_log_direction dir);
static CsrUint32 write_uint32(void *buf, const CsrUint32 offset,
const CsrUint32 val);
static CsrUint32 write_bytes(void *buf, const CsrUint32 offset,
- const CsrUint8 *data, const CsrUint32 len);
+ const u8 *data, const CsrUint32 len);
static CsrUint32 write_tag(void *buf, const CsrUint32 offset,
const CsrCharString *tag_str);
static CsrUint32 write_chunk(void *buf, const CsrUint32 offset,
}
-static CsrUint32 xbv2uint(CsrUint8 *ptr, CsrInt32 len)
+static CsrUint32 xbv2uint(u8 *ptr, CsrInt32 len)
{
CsrUint32 u = 0;
CsrInt16 i;
static CsrInt32 read_tag(card_t *card, ct_t *ct, tag_t *tag)
{
- CsrUint8 buf[8];
+ u8 buf[8];
CsrInt32 n;
n = (*ct->iread)(card->ospriv, ct->dlpriv, ct->ioffset, buf, 8);
static CsrInt32 read_uint(card_t *card, ct_t *ct, CsrUint32 *u, CsrUint32 len)
{
- CsrUint8 buf[4];
+ u8 buf[4];
/* Integer cannot be more than 4 bytes */
if (len > 4)
static CsrUint32 write_uint16(void *buf, const CsrUint32 offset, const CsrUint16 val)
{
- CsrUint8 *dst = (CsrUint8 *)buf + offset;
- *dst++ = (CsrUint8)(val & 0xff); /* LSB first */
- *dst = (CsrUint8)(val >> 8);
+ u8 *dst = (u8 *)buf + offset;
+ *dst++ = (u8)(val & 0xff); /* LSB first */
+ *dst = (u8)(val >> 8);
return sizeof(CsrUint16);
}
}
-static CsrUint32 write_bytes(void *buf, const CsrUint32 offset, const CsrUint8 *data, const CsrUint32 len)
+static CsrUint32 write_bytes(void *buf, const CsrUint32 offset, const u8 *data, const CsrUint32 len)
{
CsrUint32 i;
- CsrUint8 *dst = (CsrUint8 *)buf + offset;
+ u8 *dst = (u8 *)buf + offset;
for (i = 0; i < len; i++)
{
- *dst++ = *((CsrUint8 *)data + i);
+ *dst++ = *((u8 *)data + i);
}
return len;
}
static CsrUint32 write_tag(void *buf, const CsrUint32 offset, const CsrCharString *tag_str)
{
- CsrUint8 *dst = (CsrUint8 *)buf + offset;
+ u8 *dst = (u8 *)buf + offset;
CsrMemCpy(dst, tag_str, 4);
return 4;
}
static CsrUint16 calc_checksum(void *buf, const CsrUint32 offset, const CsrUint32 bytes_len)
{
CsrUint32 i;
- CsrUint8 *src = (CsrUint8 *)buf + offset;
+ u8 *src = (u8 *)buf + offset;
CsrUint16 sum = 0;
CsrUint16 val;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint8 value;
+ u8 value;
} CsrWifiEventCsrUint8;
/*----------------------------------------------------------------------------*
* Allocates and fills in a message with the signature CsrWifiEventCsrUint8
*
*----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint8* CsrWifiEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint8 value);
+CsrWifiEventCsrUint8* CsrWifiEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, u8 value);
typedef struct
{
{
CsrWifiFsmEvent common;
CsrUint16 value16;
- CsrUint8 value8;
+ 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, CsrUint8 value8);
+CsrWifiEventCsrUint16CsrUint8* CsrWifiEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint16 value16, u8 value8);
#ifdef __cplusplus
}
#endif
-void CsrUint16SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint16 v);
-void CsrUint24SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v);
-void CsrUint32SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v);
+void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, CsrUint16 v);
+void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v);
+void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v);
-void CsrUint16DesBigEndian(CsrUint16 *v, CsrUint8 *buffer, CsrSize *offset);
-void CsrUint24DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset);
-void CsrUint32DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset);
+void CsrUint16DesBigEndian(CsrUint16 *v, u8 *buffer, CsrSize *offset);
+void CsrUint24DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset);
+void CsrUint32DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset);
-void CsrUint24Ser(CsrUint8 *ptr, CsrSize *len, CsrUint32 v);
-void CsrUint24Des(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset);
+void CsrUint24Ser(u8 *ptr, CsrSize *len, CsrUint32 v);
+void CsrUint24Des(CsrUint32 *v, u8 *buffer, CsrSize *offset);
CsrSize CsrWifiEventSizeof(void *msg);
-CsrUint8* CsrWifiEventSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventDes(CsrUint8 *buffer, CsrSize length);
+u8* CsrWifiEventSer(u8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventDes(u8 *buffer, CsrSize length);
CsrSize CsrWifiEventCsrUint8Sizeof(void *msg);
-CsrUint8* CsrWifiEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint8Des(CsrUint8 *buffer, CsrSize length);
+u8* CsrWifiEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint8Des(u8 *buffer, CsrSize length);
CsrSize CsrWifiEventCsrUint16Sizeof(void *msg);
-CsrUint8* CsrWifiEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint16Des(CsrUint8 *buffer, CsrSize length);
+u8* CsrWifiEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint16Des(u8 *buffer, CsrSize length);
CsrSize CsrWifiEventCsrUint32Sizeof(void *msg);
-CsrUint8* CsrWifiEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint32Des(CsrUint8 *buffer, CsrSize length);
+u8* CsrWifiEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint32Des(u8 *buffer, CsrSize length);
CsrSize CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg);
-CsrUint8* CsrWifiEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length);
+u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length);
#ifdef __cplusplus
}
msg__->interfaceTag = (interfaceTag__); \
msg__->selectedDevicePasswordId = (selectedDevicePasswordId__); \
msg__->selectedConfigMethod = (selectedConfigMethod__); \
- CsrMemCpy(msg__->pin, (pin__), sizeof(CsrUint8) * 8);
+ CsrMemCpy(msg__->pin, (pin__), sizeof(u8) * 8);
#define CsrWifiNmeApWpsRegisterReqSendTo(dst__, src__, interfaceTag__, selectedDevicePasswordId__, selectedConfigMethod__, pin__) \
{ \
- Use the specified passphrase as credential
*******************************************************************************/
-typedef CsrUint8 CsrWifiNmeApPersCredentialType;
+typedef u8 CsrWifiNmeApPersCredentialType;
#define CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK ((CsrWifiNmeApPersCredentialType) 0x00)
#define CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE ((CsrWifiNmeApPersCredentialType) 0x01)
CsrBool apStrictGtkRekey;
CsrUint16 apGmkTimeout;
CsrUint16 apResponseTimeout;
- CsrUint8 apRetransLimit;
+ u8 apRetransLimit;
} CsrWifiNmeApConfig;
/*******************************************************************************
CsrUint16 interfaceTag;
CsrWifiSmeWpsDpid selectedDevicePasswordId;
CsrWifiSmeWpsConfigType selectedConfigMethod;
- CsrUint8 pin[8];
+ u8 pin[8];
} CsrWifiNmeApWpsRegisterReq;
/*******************************************************************************
CsrBool cloakSsid;
CsrWifiSsid ssid;
CsrWifiSmeRadioIF ifIndex;
- CsrUint8 channel;
+ u8 channel;
CsrWifiNmeApCredentials apCredentials;
- CsrUint8 maxConnections;
+ u8 maxConnections;
CsrWifiSmeApP2pGoConfig p2pGoParam;
CsrBool wpsEnabled;
} CsrWifiNmeApStartReq;
bufferSize += 1; /* CsrBool primitive->apConfig.apStrictGtkRekey */
bufferSize += 2; /* CsrUint16 primitive->apConfig.apGmkTimeout */
bufferSize += 2; /* CsrUint16 primitive->apConfig.apResponseTimeout */
- bufferSize += 1; /* CsrUint8 primitive->apConfig.apRetransLimit */
+ bufferSize += 1; /* u8 primitive->apConfig.apRetransLimit */
bufferSize += 1; /* CsrWifiSmeApPhySupportMask primitive->apMacConfig.phySupportedBitmap */
bufferSize += 2; /* CsrUint16 primitive->apMacConfig.beaconInterval */
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.dtimPeriod */
+ bufferSize += 1; /* u8 primitive->apMacConfig.dtimPeriod */
bufferSize += 2; /* CsrUint16 primitive->apMacConfig.maxListenInterval */
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.supportedRatesCount */
- bufferSize += 20; /* CsrUint8 primitive->apMacConfig.supportedRates[20] */
+ bufferSize += 1; /* u8 primitive->apMacConfig.supportedRatesCount */
+ bufferSize += 20; /* u8 primitive->apMacConfig.supportedRates[20] */
bufferSize += 1; /* CsrWifiSmePreambleType primitive->apMacConfig.preamble */
bufferSize += 1; /* CsrBool primitive->apMacConfig.shortSlotTimeEnabled */
bufferSize += 1; /* CsrWifiSmeCtsProtectionType primitive->apMacConfig.ctsProtectionType */
CsrUint16 i2;
for (i2 = 0; i2 < 4; i2++)
{
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApParams[i2].cwMin */
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApParams[i2].cwMax */
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApParams[i2].aifs */
+ 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 += 1; /* CsrBool primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory */
}
CsrUint16 i2;
for (i2 = 0; i2 < 4; i2++)
{
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApBcParams[i2].cwMin */
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApBcParams[i2].cwMax */
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApBcParams[i2].aifs */
+ 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 += 1; /* CsrBool primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory */
}
}
bufferSize += 1; /* CsrWifiSmeApAccessType primitive->apMacConfig.accessType */
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.macAddressListCount */
+ bufferSize += 1; /* u8 primitive->apMacConfig.macAddressListCount */
{
CsrUint16 i2;
for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
{
- bufferSize += 6; /* CsrUint8 primitive->apMacConfig.macAddressList[i2].a[6] */
+ bufferSize += 6; /* u8 primitive->apMacConfig.macAddressList[i2].a[6] */
}
}
bufferSize += 1; /* CsrBool primitive->apMacConfig.apHtParams.greenfieldSupported */
bufferSize += 1; /* CsrBool primitive->apMacConfig.apHtParams.shortGi20MHz */
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.apHtParams.rxStbc */
+ bufferSize += 1; /* u8 primitive->apMacConfig.apHtParams.rxStbc */
bufferSize += 1; /* CsrBool primitive->apMacConfig.apHtParams.rifsModeAllowed */
- bufferSize += 1; /* CsrUint8 primitive->apMacConfig.apHtParams.htProtection */
+ bufferSize += 1; /* u8 primitive->apMacConfig.apHtParams.htProtection */
bufferSize += 1; /* CsrBool primitive->apMacConfig.apHtParams.dualCtsProtection */
return bufferSize;
}
-CsrUint8* CsrWifiNmeApConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apGroupkeyTimeout);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apConfig.apStrictGtkRekey);
+ CsrUint8Ser(ptr, len, (u8) primitive->apConfig.apStrictGtkRekey);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apGmkTimeout);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apResponseTimeout);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apConfig.apRetransLimit);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.phySupportedBitmap);
+ CsrUint8Ser(ptr, len, (u8) primitive->apConfig.apRetransLimit);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.phySupportedBitmap);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.beaconInterval);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.dtimPeriod);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.dtimPeriod);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.maxListenInterval);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.supportedRatesCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.supportedRatesCount);
CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.supportedRates, ((CsrUint16) (20)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.preamble);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.shortSlotTimeEnabled);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.ctsProtectionType);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmEnabled);
+ 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;
for (i2 = 0; i2 < 4; i2++)
{
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].cwMin);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].cwMax);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].aifs);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory);
}
}
{
CsrUint16 i2;
for (i2 = 0; i2 < 4; i2++)
{
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].cwMin);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].cwMax);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].aifs);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory);
}
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.accessType);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.macAddressListCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.accessType);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.macAddressListCount);
{
CsrUint16 i2;
for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.macAddressList[i2].a, ((CsrUint16) (6)));
}
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.greenfieldSupported);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.shortGi20MHz);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.rxStbc);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.rifsModeAllowed);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.htProtection);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.dualCtsProtection);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.greenfieldSupported);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.shortGi20MHz);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.rxStbc);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.rifsModeAllowed);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.htProtection);
+ CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.dualCtsProtection);
return(ptr);
}
-void* CsrWifiNmeApConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApConfigSetReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->apConfig.apGroupkeyTimeout, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apConfig.apStrictGtkRekey, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apConfig.apStrictGtkRekey, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->apConfig.apGmkTimeout, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->apConfig.apResponseTimeout, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apConfig.apRetransLimit, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.phySupportedBitmap, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apConfig.apRetransLimit, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.phySupportedBitmap, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.beaconInterval, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.dtimPeriod, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.dtimPeriod, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.maxListenInterval, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.supportedRatesCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.supportedRatesCount, buffer, &offset);
CsrMemCpyDes(primitive->apMacConfig.supportedRates, buffer, &offset, ((CsrUint16) (20)));
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.preamble, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.shortSlotTimeEnabled, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.ctsProtectionType, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmEnabled, buffer, &offset);
+ 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;
for (i2 = 0; i2 < 4; i2++)
{
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].cwMin, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].cwMax, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].aifs, buffer, &offset);
+ 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);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory, buffer, &offset);
}
}
{
CsrUint16 i2;
for (i2 = 0; i2 < 4; i2++)
{
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMin, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMax, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].aifs, buffer, &offset);
+ 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);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory, buffer, &offset);
}
}
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.accessType, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.macAddressListCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.accessType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.macAddressListCount, buffer, &offset);
primitive->apMacConfig.macAddressList = NULL;
if (primitive->apMacConfig.macAddressListCount)
{
CsrMemCpyDes(primitive->apMacConfig.macAddressList[i2].a, buffer, &offset, ((CsrUint16) (6)));
}
}
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.greenfieldSupported, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.shortGi20MHz, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.rxStbc, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.rifsModeAllowed, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.htProtection, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.dualCtsProtection, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.greenfieldSupported, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.shortGi20MHz, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.rxStbc, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.rifsModeAllowed, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.htProtection, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.dualCtsProtection, buffer, &offset);
return primitive;
}
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiSmeWpsDpid primitive->selectedDevicePasswordId */
bufferSize += 2; /* CsrWifiSmeWpsConfigType primitive->selectedConfigMethod */
- bufferSize += 8; /* CsrUint8 primitive->pin[8] */
+ bufferSize += 8; /* u8 primitive->pin[8] */
return bufferSize;
}
-CsrUint8* CsrWifiNmeApWpsRegisterReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *)msg;
*len = 0;
}
-void* CsrWifiNmeApWpsRegisterReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize length)
{
CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterReq));
CsrSize offset;
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeApType primitive->apType */
bufferSize += 1; /* CsrBool primitive->cloakSsid */
- bufferSize += 32; /* CsrUint8 primitive->ssid.ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->ssid.length */
+ bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
+ bufferSize += 1; /* u8 primitive->ssid.length */
bufferSize += 1; /* CsrWifiSmeRadioIF primitive->ifIndex */
- bufferSize += 1; /* CsrUint8 primitive->channel */
+ bufferSize += 1; /* u8 primitive->channel */
bufferSize += 1; /* CsrWifiSmeApAuthType primitive->apCredentials.authType */
switch (primitive->apCredentials.authType)
{
case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
- bufferSize += 1; /* CsrUint8 primitive->apCredentials.nmeAuthType.openSystemEmpty.empty */
+ bufferSize += 1; /* u8 primitive->apCredentials.nmeAuthType.openSystemEmpty.empty */
break;
case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
bufferSize += 1; /* CsrWifiSmeWepCredentialType primitive->apCredentials.nmeAuthType.authwep.wepKeyType */
{
case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
bufferSize += 1; /* CsrWifiSmeWepAuthMode primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType */
- bufferSize += 1; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey */
- bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1[13] */
- bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2[13] */
- bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3[13] */
- bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4[13] */
+ bufferSize += 1; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey */
+ bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1[13] */
+ bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2[13] */
+ bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3[13] */
+ bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4[13] */
break;
case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
bufferSize += 1; /* CsrWifiSmeWepAuthMode primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType */
- bufferSize += 1; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey */
- bufferSize += 5; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1[5] */
- bufferSize += 5; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2[5] */
- bufferSize += 5; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3[5] */
- bufferSize += 5; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4[5] */
+ bufferSize += 1; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey */
+ bufferSize += 5; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1[5] */
+ bufferSize += 5; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2[5] */
+ bufferSize += 5; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3[5] */
+ bufferSize += 5; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4[5] */
break;
default:
break;
{
case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
bufferSize += 2; /* CsrUint16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode */
- bufferSize += 32; /* CsrUint8 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk[32] */
+ 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 */
default:
break;
}
- bufferSize += 1; /* CsrUint8 primitive->maxConnections */
+ bufferSize += 1; /* u8 primitive->maxConnections */
bufferSize += 1; /* CsrWifiSmeP2pGroupCapabilityMask primitive->p2pGoParam.groupCapability */
- bufferSize += 3; /* CsrUint8 primitive->p2pGoParam.operatingChanList.country[3] */
- bufferSize += 1; /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryListCount */
+ bufferSize += 3; /* u8 primitive->p2pGoParam.operatingChanList.country[3] */
+ bufferSize += 1; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryListCount */
{
CsrUint16 i3;
for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
{
- bufferSize += 1; /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass */
- bufferSize += 1; /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount */
- bufferSize += primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount; /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel */
+ bufferSize += 1; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass */
+ bufferSize += 1; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount */
+ bufferSize += primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel */
}
}
bufferSize += 1; /* CsrBool primitive->p2pGoParam.opPsEnabled */
- bufferSize += 1; /* CsrUint8 primitive->p2pGoParam.ctWindow */
+ bufferSize += 1; /* u8 primitive->p2pGoParam.ctWindow */
bufferSize += 1; /* CsrWifiSmeP2pNoaConfigMethod primitive->p2pGoParam.noaConfigMethod */
bufferSize += 1; /* CsrBool primitive->p2pGoParam.allowNoaWithNonP2pDevices */
bufferSize += 1; /* CsrBool primitive->wpsEnabled */
}
-CsrUint8* CsrWifiNmeApStartReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apType);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakSsid);
+ CsrUint8Ser(ptr, len, (u8) primitive->apType);
+ CsrUint8Ser(ptr, len, (u8) primitive->cloakSsid);
CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid.length);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ifIndex);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->channel);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.authType);
+ CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
+ CsrUint8Ser(ptr, len, (u8) primitive->ifIndex);
+ CsrUint8Ser(ptr, len, (u8) primitive->channel);
+ CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.authType);
switch (primitive->apCredentials.authType)
{
case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.openSystemEmpty.empty);
+ CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.openSystemEmpty.empty);
break;
case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepKeyType);
+ CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepKeyType);
switch (primitive->apCredentials.nmeAuthType.authwep.wepKeyType)
{
case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey);
+ 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)));
break;
case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey);
+ 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)));
}
break;
case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase);
+ CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase);
switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
{
case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
default:
break;
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->maxConnections);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.groupCapability);
+ CsrUint8Ser(ptr, len, (u8) primitive->maxConnections);
+ CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.groupCapability);
CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.country, ((CsrUint16) (3)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.operatingChanList.channelEntryListCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryListCount);
{
CsrUint16 i3;
for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
{
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
+ 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)));
}
}
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.opPsEnabled);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.ctWindow);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.noaConfigMethod);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.allowNoaWithNonP2pDevices);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsEnabled);
+ CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.opPsEnabled);
+ CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.ctWindow);
+ CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.noaConfigMethod);
+ CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.allowNoaWithNonP2pDevices);
+ CsrUint8Ser(ptr, len, (u8) primitive->wpsEnabled);
return(ptr);
}
-void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize length)
{
CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apType, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->cloakSsid, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->cloakSsid, buffer, &offset);
CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->ssid.length, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ifIndex, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->channel, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apCredentials.authType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ifIndex, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->channel, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apCredentials.authType, buffer, &offset);
switch (primitive->apCredentials.authType)
{
case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
- CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.openSystemEmpty.empty, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.openSystemEmpty.empty, buffer, &offset);
break;
case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
- CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepKeyType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepKeyType, buffer, &offset);
switch (primitive->apCredentials.nmeAuthType.authwep.wepKeyType)
{
case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
- CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey, buffer, &offset);
+ 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)));
break;
case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
- CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey, buffer, &offset);
+ 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)));
}
break;
case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
- CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport, buffer, &offset);
+ 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);
- CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase, 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:
default:
break;
}
- CsrUint8Des((CsrUint8 *) &primitive->maxConnections, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.groupCapability, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->maxConnections, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->p2pGoParam.groupCapability, buffer, &offset);
CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.country, buffer, &offset, ((CsrUint16) (3)));
- CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.operatingChanList.channelEntryListCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryListCount, buffer, &offset);
primitive->p2pGoParam.operatingChanList.channelEntryList = NULL;
if (primitive->p2pGoParam.operatingChanList.channelEntryListCount)
{
CsrUint16 i3;
for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
{
- CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount, buffer, &offset);
if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
{
- primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel = (CsrUint8 *)CsrPmemAlloc(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)));
}
else
}
}
}
- CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.opPsEnabled, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.ctWindow, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.noaConfigMethod, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.allowNoaWithNonP2pDevices, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->wpsEnabled, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->p2pGoParam.opPsEnabled, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->p2pGoParam.ctWindow, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->p2pGoParam.noaConfigMethod, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->p2pGoParam.allowNoaWithNonP2pDevices, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->wpsEnabled, buffer, &offset);
return primitive;
}
CsrUint16 i1;
for (i1 = 0; i1 < 4; i1++)
{
- bufferSize += 1; /* CsrUint8 primitive->wmmApParams[i1].cwMin */
- bufferSize += 1; /* CsrUint8 primitive->wmmApParams[i1].cwMax */
- bufferSize += 1; /* CsrUint8 primitive->wmmApParams[i1].aifs */
+ 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 += 1; /* CsrBool primitive->wmmApParams[i1].admissionControlMandatory */
}
CsrUint16 i1;
for (i1 = 0; i1 < 4; i1++)
{
- bufferSize += 1; /* CsrUint8 primitive->wmmApBcParams[i1].cwMin */
- bufferSize += 1; /* CsrUint8 primitive->wmmApBcParams[i1].cwMax */
- bufferSize += 1; /* CsrUint8 primitive->wmmApBcParams[i1].aifs */
+ 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 += 1; /* CsrBool primitive->wmmApBcParams[i1].admissionControlMandatory */
}
}
-CsrUint8* CsrWifiNmeApWmmParamUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *)msg;
*len = 0;
CsrUint16 i1;
for (i1 = 0; i1 < 4; i1++)
{
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].cwMin);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].cwMax);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].aifs);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].admissionControlMandatory);
+ CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].admissionControlMandatory);
}
}
{
CsrUint16 i1;
for (i1 = 0; i1 < 4; i1++)
{
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].cwMin);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].cwMax);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].aifs);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].admissionControlMandatory);
+ CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].admissionControlMandatory);
}
}
return(ptr);
}
-void* CsrWifiNmeApWmmParamUpdateReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize length)
{
CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWmmParamUpdateReq));
CsrSize offset;
CsrUint16 i1;
for (i1 = 0; i1 < 4; i1++)
{
- CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].cwMin, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].cwMax, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].aifs, buffer, &offset);
+ 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);
- CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].admissionControlMandatory, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->wmmApParams[i1].admissionControlMandatory, buffer, &offset);
}
}
{
CsrUint16 i1;
for (i1 = 0; i1 < 4; i1++)
{
- CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].cwMin, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].cwMax, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].aifs, buffer, &offset);
+ 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);
- CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].admissionControlMandatory, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].admissionControlMandatory, buffer, &offset);
}
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 6; /* CsrUint8 primitive->staMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->staMacAddress.a[6] */
bufferSize += 1; /* CsrBool primitive->keepBlocking */
return bufferSize;
}
-CsrUint8* CsrWifiNmeApStaRemoveReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg)
{
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)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->keepBlocking);
+ CsrUint8Ser(ptr, len, (u8) primitive->keepBlocking);
return(ptr);
}
-void* CsrWifiNmeApStaRemoveReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize length)
{
CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStaRemoveReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrMemCpyDes(primitive->staMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->keepBlocking, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->keepBlocking, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiNmeApWpsRegisterCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *)msg;
*len = 0;
}
-void* CsrWifiNmeApWpsRegisterCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterCfm));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 40) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 32; /* CsrUint8 primitive->ssid.ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->ssid.length */
+ bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
+ bufferSize += 1; /* u8 primitive->ssid.length */
return bufferSize;
}
-CsrUint8* CsrWifiNmeApStartCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid.length);
+ CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
return(ptr);
}
-void* CsrWifiNmeApStartCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartCfm));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->ssid.length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiNmeApStopCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *)msg;
*len = 0;
}
-void* CsrWifiNmeApStopCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiNmeApStopIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->apType);
+ CsrUint8Ser(ptr, len, (u8) primitive->apType);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
return(ptr);
}
-void* CsrWifiNmeApStopIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize length)
{
CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->apType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->apType, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
return primitive;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeMediaStatus primitive->mediaStatus */
- bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
- bufferSize += 6; /* CsrUint8 primitive->peerDeviceAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerDeviceAddress.a[6] */
return bufferSize;
}
-CsrUint8* CsrWifiNmeApStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->mediaStatus);
+ 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)));
return(ptr);
}
-void* CsrWifiNmeApStationIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStationIndDes(u8 *buffer, CsrSize length)
{
CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStationInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->mediaStatus, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
CsrMemCpyDes(primitive->peerDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
extern void CsrWifiNmeApPfree(void *ptr);
-extern CsrUint8* CsrWifiNmeApConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg);
extern void CsrWifiNmeApConfigSetReqSerFree(void *msg);
-extern CsrUint8* CsrWifiNmeApWpsRegisterReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApWpsRegisterReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg);
#define CsrWifiNmeApWpsRegisterReqSerFree CsrWifiNmeApPfree
-extern CsrUint8* CsrWifiNmeApStartReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStartReqSizeof(void *msg);
extern void CsrWifiNmeApStartReqSerFree(void *msg);
#define CsrWifiNmeApStopReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiNmeApStopReqSerFree CsrWifiNmeApPfree
-extern CsrUint8* CsrWifiNmeApWmmParamUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApWmmParamUpdateReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg);
#define CsrWifiNmeApWmmParamUpdateReqSerFree CsrWifiNmeApPfree
-extern CsrUint8* CsrWifiNmeApStaRemoveReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStaRemoveReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg);
#define CsrWifiNmeApStaRemoveReqSerFree CsrWifiNmeApPfree
#define CsrWifiNmeApConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiNmeApConfigSetCfmSerFree CsrWifiNmeApPfree
-extern CsrUint8* CsrWifiNmeApWpsRegisterCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApWpsRegisterCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg);
#define CsrWifiNmeApWpsRegisterCfmSerFree CsrWifiNmeApPfree
-extern CsrUint8* CsrWifiNmeApStartCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStartCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStartCfmSizeof(void *msg);
#define CsrWifiNmeApStartCfmSerFree CsrWifiNmeApPfree
-extern CsrUint8* CsrWifiNmeApStopCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStopCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStopCfmSizeof(void *msg);
#define CsrWifiNmeApStopCfmSerFree CsrWifiNmeApPfree
-extern CsrUint8* CsrWifiNmeApStopIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStopIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStopIndSizeof(void *msg);
#define CsrWifiNmeApStopIndSerFree CsrWifiNmeApPfree
#define CsrWifiNmeApWmmParamUpdateCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiNmeApWmmParamUpdateCfmSerFree CsrWifiNmeApPfree
-extern CsrUint8* CsrWifiNmeApStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStationIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStationIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStationIndSizeof(void *msg);
#define CsrWifiNmeApStationIndSerFree CsrWifiNmeApPfree
#define CsrWifiNmeSimUmtsAuthIndCreate(msg__, dst__, src__, rand__, autn__) \
msg__ = (CsrWifiNmeSimUmtsAuthInd *) CsrPmemAlloc(sizeof(CsrWifiNmeSimUmtsAuthInd)); \
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_SIM_UMTS_AUTH_IND, dst__, src__); \
- CsrMemCpy(msg__->rand, (rand__), sizeof(CsrUint8) * 16); \
- CsrMemCpy(msg__->autn, (autn__), sizeof(CsrUint8) * 16);
+ CsrMemCpy(msg__->rand, (rand__), sizeof(u8) * 16); \
+ CsrMemCpy(msg__->autn, (autn__), sizeof(u8) * 16);
#define CsrWifiNmeSimUmtsAuthIndSendTo(dst__, src__, rand__, autn__) \
{ \
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_SIM_UMTS_AUTH_RES, dst__, src__); \
msg__->status = (status__); \
msg__->result = (result__); \
- CsrMemCpy(msg__->umtsCipherKey, (umtsCipherKey__), sizeof(CsrUint8) * 16); \
- CsrMemCpy(msg__->umtsIntegrityKey, (umtsIntegrityKey__), sizeof(CsrUint8) * 16); \
+ CsrMemCpy(msg__->umtsCipherKey, (umtsCipherKey__), sizeof(u8) * 16); \
+ CsrMemCpy(msg__->umtsIntegrityKey, (umtsIntegrityKey__), sizeof(u8) * 16); \
msg__->resParameterLength = (resParameterLength__); \
msg__->resParameter = (resParameter__); \
- CsrMemCpy(msg__->auts, (auts__), sizeof(CsrUint8) * 14);
+ CsrMemCpy(msg__->auts, (auts__), sizeof(u8) * 14);
#define CsrWifiNmeSimUmtsAuthResSendTo(dst__, src__, status__, result__, umtsCipherKey__, umtsIntegrityKey__, resParameterLength__, resParameter__, auts__) \
{ \
msg__ = (CsrWifiNmeWpsReq *) CsrPmemAlloc(sizeof(CsrWifiNmeWpsReq)); \
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_WPS_REQ, dst__, src__); \
msg__->interfaceTag = (interfaceTag__); \
- CsrMemCpy(msg__->pin, (pin__), sizeof(CsrUint8) * 8); \
+ CsrMemCpy(msg__->pin, (pin__), sizeof(u8) * 8); \
msg__->ssid = (ssid__); \
msg__->bssid = (bssid__);
- P2P mode of operation.
*******************************************************************************/
-typedef CsrUint8 CsrWifiNmeBssType;
+typedef u8 CsrWifiNmeBssType;
#define CSR_WIFI_NME_BSS_TYPE_INFRASTRUCTURE ((CsrWifiNmeBssType) 0x00)
#define CSR_WIFI_NME_BSS_TYPE_ADHOC ((CsrWifiNmeBssType) 0x01)
#define CSR_WIFI_NME_BSS_TYPE_RESERVED ((CsrWifiNmeBssType) 0x02)
CSR_WIFI_NME_CCX_OPTION_CCKM - CCX option cckm is set.
*******************************************************************************/
-typedef CsrUint8 CsrWifiNmeCcxOptionsMask;
+typedef u8 CsrWifiNmeCcxOptionsMask;
#define CSR_WIFI_NME_CCX_OPTION_NONE ((CsrWifiNmeCcxOptionsMask) 0x00)
#define CSR_WIFI_NME_CCX_OPTION_CCKM ((CsrWifiNmeCcxOptionsMask) 0x01)
CSR_WIFI_PIN_ENTRY_ENTER_PIN -
*******************************************************************************/
-typedef CsrUint8 CsrWifiNmeConfigAction;
+typedef u8 CsrWifiNmeConfigAction;
#define CSR_WIFI_PIN_ENTRY_PUSH_BUTTON ((CsrWifiNmeConfigAction) 0x00)
#define CSR_WIFI_PIN_ENTRY_DISPLAY_PIN ((CsrWifiNmeConfigAction) 0x01)
#define CSR_WIFI_PIN_ENTRY_ENTER_PIN ((CsrWifiNmeConfigAction) 0x02)
- NME is in the process of disconnecting.
*******************************************************************************/
-typedef CsrUint8 CsrWifiNmeConnectionStatus;
+typedef u8 CsrWifiNmeConnectionStatus;
#define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_DISCONNECTED ((CsrWifiNmeConnectionStatus) 0x00)
#define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_CONNECTING ((CsrWifiNmeConnectionStatus) 0x01)
#define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_AUTHENTICATING ((CsrWifiNmeConnectionStatus) 0x02)
- Unknown Security Error.
*******************************************************************************/
-typedef CsrUint8 CsrWifiNmeSecError;
+typedef u8 CsrWifiNmeSecError;
#define CSR_WIFI_NME_SEC_ERROR_SEC_ERROR_UNKNOWN ((CsrWifiNmeSecError) 0x00)
/*******************************************************************************
UMTS and GSM authentications.
*******************************************************************************/
-typedef CsrUint8 CsrWifiNmeSimCardType;
+typedef u8 CsrWifiNmeSimCardType;
#define CSR_WIFI_NME_SIM_CARD_TYPE_2G ((CsrWifiNmeSimCardType) 0x01)
#define CSR_WIFI_NME_SIM_CARD_TYPE_3G ((CsrWifiNmeSimCardType) 0x02)
#define CSR_WIFI_NME_SIM_CARD_TYPE_2G3G ((CsrWifiNmeSimCardType) 0x03)
aborted.
*******************************************************************************/
-typedef CsrUint8 CsrWifiNmeUmtsAuthResult;
+typedef u8 CsrWifiNmeUmtsAuthResult;
#define CSR_WIFI_NME_UMTS_AUTH_RESULT_SUCCESS ((CsrWifiNmeUmtsAuthResult) 0x00)
#define CSR_WIFI_NME_UMTS_AUTH_RESULT_SYNC_FAIL ((CsrWifiNmeUmtsAuthResult) 0x01)
#define CSR_WIFI_NME_UMTS_AUTH_RESULT_REJECT ((CsrWifiNmeUmtsAuthResult) 0x02)
- WMM AP may deliver a maximum of 6 buffered frames per USP.
*******************************************************************************/
-typedef CsrUint8 CsrWifiNmeWmmQosInfo;
+typedef u8 CsrWifiNmeWmmQosInfo;
#define CSR_WIFI_NME_WMM_QOS_INFO_AC_MAX_SP_ALL ((CsrWifiNmeWmmQosInfo) 0x00)
#define CSR_WIFI_NME_WMM_QOS_INFO_AC_VO ((CsrWifiNmeWmmQosInfo) 0x01)
#define CSR_WIFI_NME_WMM_QOS_INFO_AC_VI ((CsrWifiNmeWmmQosInfo) 0x02)
Mask type for use with the values defined by CsrWifiNmeWmmQosInfo
*******************************************************************************/
-typedef CsrUint8 CsrWifiNmeWmmQosInfoMask;
+typedef u8 CsrWifiNmeWmmQosInfoMask;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint8 empty;
+ u8 empty;
} CsrWifiNmeEmpty;
/*******************************************************************************
typedef struct
{
CsrUint16 encryptionMode;
- CsrUint8 psk[32];
+ u8 psk[32];
} CsrWifiNmePsk;
/*******************************************************************************
typedef struct
{
CsrUint32 certificateLength;
- CsrUint8 *certificate;
+ u8 *certificate;
CsrUint16 privateKeyLength;
- CsrUint8 *privateKey;
+ u8 *privateKey;
CsrUint32 caCertificateLength;
- CsrUint8 *caCertificate;
+ u8 *caCertificate;
} CsrWifiNmeWapiCredentials;
/*******************************************************************************
CsrCharString *userPassword;
CsrCharString *authServerUserIdentity;
CsrUint32 clientCertificateLength;
- CsrUint8 *clientCertificate;
+ u8 *clientCertificate;
CsrUint32 certificateAuthorityCertificateLength;
- CsrUint8 *certificateAuthorityCertificate;
+ u8 *certificateAuthorityCertificate;
CsrUint16 privateKeyLength;
- CsrUint8 *privateKey;
+ u8 *privateKey;
CsrCharString *privateKeyPassword;
CsrUint32 sessionLength;
- CsrUint8 *session;
+ u8 *session;
CsrBool allowPacProvisioning;
CsrUint32 pacLength;
- CsrUint8 *pac;
+ u8 *pac;
CsrCharString *pacPassword;
} CsrWifiNmeEapCredentials;
{
CsrWifiMacAddress p2pDeviceId;
CsrWifiSmeP2pGroupCapabilityMask groupCapabilityMask;
- CsrUint8 groupOwnerIntent;
+ u8 groupOwnerIntent;
} CsrWifiNmePeerConfig;
/*******************************************************************************
typedef struct
{
CsrWifiSmeAuthModeMask wepAuthType;
- CsrUint8 selectedWepKey;
- CsrUint8 key1[13];
- CsrUint8 key2[13];
- CsrUint8 key3[13];
- CsrUint8 key4[13];
+ u8 selectedWepKey;
+ u8 key1[13];
+ u8 key2[13];
+ u8 key3[13];
+ u8 key4[13];
} CsrWifiNmeWep128Keys;
/*******************************************************************************
typedef struct
{
CsrWifiSmeAuthModeMask wepAuthType;
- CsrUint8 selectedWepKey;
- CsrUint8 key1[5];
- CsrUint8 key2[5];
- CsrUint8 key3[5];
- CsrUint8 key4[5];
+ u8 selectedWepKey;
+ u8 key1[5];
+ u8 key2[5];
+ u8 key3[5];
+ u8 key4[5];
} CsrWifiNmeWep64Keys;
/*******************************************************************************
CsrWifiNmeProfileIdentity profileIdentity;
CsrWifiNmeWmmQosInfoMask wmmQosInfoMask;
CsrWifiNmeBssType bssType;
- CsrUint8 channelNo;
- CsrUint8 ccxOptionsMask;
+ u8 channelNo;
+ u8 ccxOptionsMask;
CsrBool cloakedSsid;
CsrWifiNmeCredentials credentials;
} CsrWifiNmeProfile;
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 profileIdentitysCount;
+ u8 profileIdentitysCount;
CsrWifiNmeProfileIdentity *profileIdentitys;
} CsrWifiNmeProfileOrderSetReq;
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 pin[8];
+ u8 pin[8];
CsrWifiSsid ssid;
CsrWifiMacAddress bssid;
} CsrWifiNmeWpsReq;
{
CsrWifiFsmEvent common;
CsrResult status;
- CsrUint8 kcsLength;
- CsrUint8 *kcs;
- CsrUint8 sresLength;
- CsrUint8 *sres;
+ u8 kcsLength;
+ u8 *kcs;
+ u8 sresLength;
+ u8 *sres;
} CsrWifiNmeSimGsmAuthRes;
/*******************************************************************************
CsrWifiFsmEvent common;
CsrResult status;
CsrWifiNmeUmtsAuthResult result;
- CsrUint8 umtsCipherKey[16];
- CsrUint8 umtsIntegrityKey[16];
- CsrUint8 resParameterLength;
- CsrUint8 *resParameter;
- CsrUint8 auts[14];
+ u8 umtsCipherKey[16];
+ u8 umtsIntegrityKey[16];
+ u8 resParameterLength;
+ u8 *resParameter;
+ u8 auts[14];
} CsrWifiNmeSimUmtsAuthRes;
/*******************************************************************************
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
CsrResult status;
- CsrUint8 connectAttemptsCount;
+ u8 connectAttemptsCount;
CsrWifiNmeConnectAttempt *connectAttempts;
} CsrWifiNmeProfileConnectCfm;
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 connectAttemptsCount;
+ u8 connectAttemptsCount;
CsrWifiNmeConnectAttempt *connectAttempts;
} CsrWifiNmeProfileDisconnectInd;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint8 randsLength;
- CsrUint8 *rands;
+ u8 randsLength;
+ u8 *rands;
} CsrWifiNmeSimGsmAuthInd;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint8 rand[16];
- CsrUint8 autn[16];
+ u8 rand[16];
+ u8 autn[16];
} CsrWifiNmeSimUmtsAuthInd;
/*******************************************************************************
extern void CsrWifiNmePfree(void *ptr);
-extern CsrUint8* CsrWifiNmeProfileSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileSetReqSizeof(void *msg);
extern void CsrWifiNmeProfileSetReqSerFree(void *msg);
-extern CsrUint8* CsrWifiNmeProfileDeleteReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileDeleteReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileDeleteReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileDeleteReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileDeleteReqSizeof(void *msg);
#define CsrWifiNmeProfileDeleteReqSerFree CsrWifiNmePfree
#define CsrWifiNmeProfileDeleteAllReqSizeof CsrWifiEventSizeof
#define CsrWifiNmeProfileDeleteAllReqSerFree CsrWifiNmePfree
-extern CsrUint8* CsrWifiNmeProfileOrderSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileOrderSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileOrderSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileOrderSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileOrderSetReqSizeof(void *msg);
extern void CsrWifiNmeProfileOrderSetReqSerFree(void *msg);
-extern CsrUint8* CsrWifiNmeProfileConnectReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileConnectReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileConnectReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileConnectReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileConnectReqSizeof(void *msg);
#define CsrWifiNmeProfileConnectReqSerFree CsrWifiNmePfree
-extern CsrUint8* CsrWifiNmeWpsReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeWpsReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeWpsReqSizeof(void *msg);
#define CsrWifiNmeWpsReqSerFree CsrWifiNmePfree
#define CsrWifiNmeConnectionStatusGetReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiNmeConnectionStatusGetReqSerFree CsrWifiNmePfree
-extern CsrUint8* CsrWifiNmeSimImsiGetResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimImsiGetResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeSimImsiGetResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimImsiGetResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeSimImsiGetResSizeof(void *msg);
extern void CsrWifiNmeSimImsiGetResSerFree(void *msg);
-extern CsrUint8* CsrWifiNmeSimGsmAuthResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimGsmAuthResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeSimGsmAuthResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimGsmAuthResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeSimGsmAuthResSizeof(void *msg);
extern void CsrWifiNmeSimGsmAuthResSerFree(void *msg);
-extern CsrUint8* CsrWifiNmeSimUmtsAuthResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimUmtsAuthResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeSimUmtsAuthResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimUmtsAuthResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeSimUmtsAuthResSizeof(void *msg);
extern void CsrWifiNmeSimUmtsAuthResSerFree(void *msg);
-extern CsrUint8* CsrWifiNmeWpsConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeWpsConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeWpsConfigSetReqSizeof(void *msg);
extern void CsrWifiNmeWpsConfigSetReqSerFree(void *msg);
#define CsrWifiNmeProfileDeleteAllCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiNmeProfileDeleteAllCfmSerFree CsrWifiNmePfree
-extern CsrUint8* CsrWifiNmeProfileOrderSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileOrderSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileOrderSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileOrderSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileOrderSetCfmSizeof(void *msg);
#define CsrWifiNmeProfileOrderSetCfmSerFree CsrWifiNmePfree
-extern CsrUint8* CsrWifiNmeProfileConnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileConnectCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileConnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileConnectCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileConnectCfmSizeof(void *msg);
extern void CsrWifiNmeProfileConnectCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiNmeWpsCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeWpsCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeWpsCfmSizeof(void *msg);
extern void CsrWifiNmeWpsCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiNmeWpsCancelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsCancelCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeWpsCancelCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsCancelCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeWpsCancelCfmSizeof(void *msg);
#define CsrWifiNmeWpsCancelCfmSerFree CsrWifiNmePfree
-extern CsrUint8* CsrWifiNmeConnectionStatusGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeConnectionStatusGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeConnectionStatusGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeConnectionStatusGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeConnectionStatusGetCfmSizeof(void *msg);
#define CsrWifiNmeConnectionStatusGetCfmSerFree CsrWifiNmePfree
-extern CsrUint8* CsrWifiNmeProfileUpdateIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileUpdateIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileUpdateIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileUpdateIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileUpdateIndSizeof(void *msg);
extern void CsrWifiNmeProfileUpdateIndSerFree(void *msg);
-extern CsrUint8* CsrWifiNmeProfileDisconnectIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileDisconnectIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileDisconnectIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileDisconnectIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileDisconnectIndSizeof(void *msg);
extern void CsrWifiNmeProfileDisconnectIndSerFree(void *msg);
#define CsrWifiNmeSimImsiGetIndSizeof CsrWifiEventSizeof
#define CsrWifiNmeSimImsiGetIndSerFree CsrWifiNmePfree
-extern CsrUint8* CsrWifiNmeSimGsmAuthIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimGsmAuthIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeSimGsmAuthIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimGsmAuthIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeSimGsmAuthIndSizeof(void *msg);
extern void CsrWifiNmeSimGsmAuthIndSerFree(void *msg);
-extern CsrUint8* CsrWifiNmeSimUmtsAuthIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimUmtsAuthIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeSimUmtsAuthIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimUmtsAuthIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeSimUmtsAuthIndSizeof(void *msg);
#define CsrWifiNmeSimUmtsAuthIndSerFree CsrWifiNmePfree
/* Common structure for NME and SME to maintain Interface mode*/
-typedef CsrUint8 CsrWifiInterfaceMode;
+typedef u8 CsrWifiInterfaceMode;
#define CSR_WIFI_MODE_NONE ((CsrWifiInterfaceMode) 0xFF)
#define CSR_WIFI_MODE_STA ((CsrWifiInterfaceMode) 0x00)
#define CSR_WIFI_MODE_AP ((CsrWifiInterfaceMode) 0x01)
typedef CsrPrim CsrWifiRouterCtrlPrim;
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteWrite)(CsrUint8 func, CsrUint32 address, CsrUint8 data);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteRead)(CsrUint8 func, CsrUint32 address, CsrUint8 *pdata);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioFirmwareDownload)(CsrUint32 length, const CsrUint8 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteWrite)(u8 func, CsrUint32 address, u8 data);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteRead)(u8 func, CsrUint32 address, u8 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioFirmwareDownload)(CsrUint32 length, const u8 *pdata);
typedef CsrResult (*CsrWifiRouterCtrlRawSdioReset)(void);
typedef CsrResult (*CsrWifiRouterCtrlRawSdioCoreDumpPrepare)(CsrBool suspendSme);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteBlockRead)(CsrUint8 func, CsrUint32 address, CsrUint8 *pdata, CsrUint32 length);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpRead16)(CsrUint8 func, CsrUint32 address, CsrUint16 *pdata);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(CsrUint8 func, CsrUint32 address, CsrUint16 data);
+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 CsrUint8 CsrWifiRouterCtrlBlockAckRole;
+typedef u8 CsrWifiRouterCtrlBlockAckRole;
#define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ORIGINATOR ((CsrWifiRouterCtrlBlockAckRole) 0x00)
#define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_RECIPIENT ((CsrWifiRouterCtrlBlockAckRole) 0x01)
-
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlControlIndication;
+typedef u8 CsrWifiRouterCtrlControlIndication;
#define CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_ERROR ((CsrWifiRouterCtrlControlIndication) 0x01)
#define CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_EXIT ((CsrWifiRouterCtrlControlIndication) 0x02)
#define CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_USER_REQUESTED ((CsrWifiRouterCtrlControlIndication) 0x03)
-
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlListAction;
+typedef u8 CsrWifiRouterCtrlListAction;
#define CSR_WIFI_ROUTER_CTRL_LIST_ACTION_GET ((CsrWifiRouterCtrlListAction) 0x00)
#define CSR_WIFI_ROUTER_CTRL_LIST_ACTION_ADD ((CsrWifiRouterCtrlListAction) 0x01)
#define CSR_WIFI_ROUTER_CTRL_LIST_ACTION_REMOVE ((CsrWifiRouterCtrlListAction) 0x02)
-
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlMediaStatus;
+typedef u8 CsrWifiRouterCtrlMediaStatus;
#define CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_CONNECTED ((CsrWifiRouterCtrlMediaStatus) 0x00)
#define CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_DISCONNECTED ((CsrWifiRouterCtrlMediaStatus) 0x01)
CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI -
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlMode;
+typedef u8 CsrWifiRouterCtrlMode;
#define CSR_WIFI_ROUTER_CTRL_MODE_NONE ((CsrWifiRouterCtrlMode) 0x00)
#define CSR_WIFI_ROUTER_CTRL_MODE_IBSS ((CsrWifiRouterCtrlMode) 0x01)
#define CSR_WIFI_ROUTER_CTRL_MODE_STA ((CsrWifiRouterCtrlMode) 0x02)
-
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlPeerStatus;
+typedef u8 CsrWifiRouterCtrlPeerStatus;
#define CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE ((CsrWifiRouterCtrlPeerStatus) 0x00)
#define CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE ((CsrWifiRouterCtrlPeerStatus) 0x01)
#define CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED ((CsrWifiRouterCtrlPeerStatus) 0x02)
-
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlQueueConfig;
+typedef u8 CsrWifiRouterCtrlQueueConfig;
#define CSR_WIFI_ROUTER_CTRL_QUEUE_BE_ENABLE ((CsrWifiRouterCtrlQueueConfig) 0x01)
#define CSR_WIFI_ROUTER_CTRL_QUEUE_BK_ENABLE ((CsrWifiRouterCtrlQueueConfig) 0x02)
#define CSR_WIFI_ROUTER_CTRL_QUEUE_VI_ENABLE ((CsrWifiRouterCtrlQueueConfig) 0x04)
-
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlTrafficType;
+typedef u8 CsrWifiRouterCtrlTrafficType;
#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_OCCASIONAL ((CsrWifiRouterCtrlTrafficType) 0x00)
#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_BURSTY ((CsrWifiRouterCtrlTrafficType) 0x01)
#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_PERIODIC ((CsrWifiRouterCtrlTrafficType) 0x02)
Mask type for use with the values defined by CsrWifiRouterCtrlQueueConfig
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlQueueConfigMask;
+typedef u8 CsrWifiRouterCtrlQueueConfigMask;
/*******************************************************************************
NAME
DESCRIPTION
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlTrafficStreamId;
+typedef u8 CsrWifiRouterCtrlTrafficStreamId;
/*******************************************************************************
{
CsrBool wmmOrQosEnabled;
CsrWifiRouterCtrlPowersaveTypeMask powersaveMode;
- CsrUint8 maxSpLength;
+ u8 maxSpLength;
CsrUint16 listenIntervalInTus;
} CsrWifiRouterCtrlStaInfo;
typedef struct
{
CsrUint32 etherType;
- CsrUint8 ipType;
+ u8 ipType;
CsrUint32 udpSourcePort;
CsrUint32 udpDestPort;
} CsrWifiRouterCtrlTrafficFilter;
CsrUint32 txFramesNum;
CsrUint32 rxBytesCount;
CsrUint32 txBytesCount;
- CsrUint8 intervals[11];
+ u8 intervals[11];
} CsrWifiRouterCtrlTrafficStats;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrUint16 mlmeCommandLength;
- CsrUint8 *mlmeCommand;
+ u8 *mlmeCommand;
CsrUint16 dataRef1Length;
- CsrUint8 *dataRef1;
+ u8 *dataRef1;
CsrUint16 dataRef2Length;
- CsrUint8 *dataRef2;
+ u8 *dataRef2;
} CsrWifiRouterCtrlHipReq;
/*******************************************************************************
CsrWifiRouterCtrlRequestorInfo clientData;
CsrResult status;
CsrWifiRouterCtrlListAction action;
- CsrUint8 getAddressesCount;
+ u8 getAddressesCount;
CsrWifiMacAddress *getAddresses;
} CsrWifiRouterCtrlMulticastAddressRes;
CsrUint16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrUint16 tclasLength;
- CsrUint8 *tclas;
+ u8 *tclas;
} CsrWifiRouterCtrlTclasAddReq;
/*******************************************************************************
CsrUint16 interfaceTag;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrUint16 tclasLength;
- CsrUint8 *tclas;
+ u8 *tclas;
} CsrWifiRouterCtrlTclasDelReq;
/*******************************************************************************
CsrWifiFsmEvent common;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrUint32 dataLength;
- CsrUint8 *data;
+ u8 *data;
} CsrWifiRouterCtrlWifiOnReq;
/*******************************************************************************
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
CsrUint16 signalLength;
- CsrUint8 *signal;
+ u8 *signal;
CsrUint16 dataLength;
- CsrUint8 *data;
+ u8 *data;
} CsrWifiRouterCtrlWapiRxPktReq;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 status;
+ u8 status;
} CsrWifiRouterCtrlWapiMulticastFilterReq;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 status;
+ u8 status;
} CsrWifiRouterCtrlWapiUnicastFilterReq;
/*******************************************************************************
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
CsrUint16 dataLength;
- CsrUint8 *data;
+ u8 *data;
} CsrWifiRouterCtrlWapiUnicastTxPktReq;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrUint16 mlmeCommandLength;
- CsrUint8 *mlmeCommand;
+ u8 *mlmeCommand;
CsrUint16 dataRef1Length;
- CsrUint8 *dataRef1;
+ u8 *dataRef1;
CsrUint16 dataRef2Length;
- CsrUint8 *dataRef2;
+ u8 *dataRef2;
} CsrWifiRouterCtrlHipInd;
/*******************************************************************************
CsrWifiRouterCtrlRequestorInfo clientData;
CsrUint16 interfaceTag;
CsrWifiRouterCtrlListAction action;
- CsrUint8 setAddressesCount;
+ u8 setAddressesCount;
CsrWifiMacAddress *setAddresses;
} CsrWifiRouterCtrlMulticastAddressInd;
CsrWifiRouterCtrlRequestorInfo clientData;
CsrUint16 interfaceTag;
CsrUint16 signalLength;
- CsrUint8 *signal;
+ u8 *signal;
CsrUint16 dataLength;
- CsrUint8 *data;
+ u8 *data;
} CsrWifiRouterCtrlWapiRxMicCheckInd;
/*******************************************************************************
CsrWifiRouterCtrlRequestorInfo clientData;
CsrUint16 interfaceTag;
CsrUint16 dataLength;
- CsrUint8 *data;
+ u8 *data;
} CsrWifiRouterCtrlWapiUnicastTxEncryptInd;
}
-CsrUint8* CsrWifiRouterCtrlConfigurePowerModeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->mode);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wakeHost);
+ CsrUint8Ser(ptr, len, (u8) primitive->wakeHost);
return(ptr);
}
-void* CsrWifiRouterCtrlConfigurePowerModeReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlConfigurePowerModeReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->mode, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->wakeHost, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->wakeHost, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
bufferSize += 2; /* CsrUint16 primitive->mlmeCommandLength */
- bufferSize += primitive->mlmeCommandLength; /* CsrUint8 primitive->mlmeCommand */
+ bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
bufferSize += 2; /* CsrUint16 primitive->dataRef1Length */
- bufferSize += primitive->dataRef1Length; /* CsrUint8 primitive->dataRef1 */
+ bufferSize += primitive->dataRef1Length; /* u8 primitive->dataRef1 */
bufferSize += 2; /* CsrUint16 primitive->dataRef2Length */
- bufferSize += primitive->dataRef2Length; /* CsrUint8 primitive->dataRef2 */
+ bufferSize += primitive->dataRef2Length; /* u8 primitive->dataRef2 */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlHipReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlHipReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlHipReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->mlmeCommandLength, buffer, &offset);
if (primitive->mlmeCommandLength)
{
- primitive->mlmeCommand = (CsrUint8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
+ primitive->mlmeCommand = (u8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((CsrUint16) (primitive->mlmeCommandLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->dataRef1Length, buffer, &offset);
if (primitive->dataRef1Length)
{
- primitive->dataRef1 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef1Length);
+ primitive->dataRef1 = (u8 *)CsrPmemAlloc(primitive->dataRef1Length);
CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((CsrUint16) (primitive->dataRef1Length)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->dataRef2Length, buffer, &offset);
if (primitive->dataRef2Length)
{
- primitive->dataRef2 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef2Length);
+ primitive->dataRef2 = (u8 *)CsrPmemAlloc(primitive->dataRef2Length);
CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((CsrUint16) (primitive->dataRef2Length)));
}
else
}
-CsrUint8* CsrWifiRouterCtrlMediaStatusReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->mediaStatus);
+ CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
return(ptr);
}
-void* CsrWifiRouterCtrlMediaStatusReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMediaStatusReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->mediaStatus, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
return primitive;
}
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
- bufferSize += 1; /* CsrUint8 primitive->getAddressesCount */
+ bufferSize += 1; /* u8 primitive->getAddressesCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->getAddresses[i1].a[6] */
+ bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlMulticastAddressResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->getAddressesCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->action);
+ CsrUint8Ser(ptr, len, (u8) primitive->getAddressesCount);
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
}
-void* CsrWifiRouterCtrlMulticastAddressResDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMulticastAddressRes));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->getAddressesCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->getAddressesCount, buffer, &offset);
primitive->getAddresses = NULL;
if (primitive->getAddressesCount)
{
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->uncontrolledPortAction */
bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->controlledPortAction */
- bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->macAddress.a[6] */
bufferSize += 1; /* CsrBool primitive->setProtection */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlPortConfigureReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->uncontrolledPortAction);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->controlledPortAction);
CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->setProtection);
+ CsrUint8Ser(ptr, len, (u8) primitive->setProtection);
return(ptr);
}
-void* CsrWifiRouterCtrlPortConfigureReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPortConfigureReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->uncontrolledPortAction, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->controlledPortAction, buffer, &offset);
CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->setProtection, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->setProtection, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiRouterCtrlQosControlReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->control);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->queueConfig);
+ CsrUint8Ser(ptr, len, (u8) primitive->queueConfig);
return(ptr);
}
-void* CsrWifiRouterCtrlQosControlReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlQosControlReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->control, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->queueConfig, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->queueConfig, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiRouterCtrlSuspendResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlSuspendResDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlSuspendRes));
CsrSize offset;
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->tclasLength */
- bufferSize += primitive->tclasLength; /* CsrUint8 primitive->tclas */
+ bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlTclasAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlTclasAddReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasAddReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
if (primitive->tclasLength)
{
- primitive->tclas = (CsrUint8 *)CsrPmemAlloc(primitive->tclasLength);
+ primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
}
else
}
-CsrUint8* CsrWifiRouterCtrlResumeResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlResumeResDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlResumeRes));
CsrSize offset;
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->tclasLength */
- bufferSize += primitive->tclasLength; /* CsrUint8 primitive->tclas */
+ bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlTclasDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlTclasDelReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasDelReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
if (primitive->tclasLength)
{
- primitive->tclas = (CsrUint8 *)CsrPmemAlloc(primitive->tclasLength);
+ primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
}
else
}
-CsrUint8* CsrWifiRouterCtrlTrafficClassificationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficType);
+ CsrUint8Ser(ptr, len, (u8) primitive->trafficType);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->period);
return(ptr);
}
-void* CsrWifiRouterCtrlTrafficClassificationReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficClassificationReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->trafficType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->trafficType, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->period, buffer, &offset);
return primitive;
bufferSize += 2; /* CsrWifiRouterCtrlTrafficConfigType primitive->trafficConfigType */
bufferSize += 2; /* CsrUint16 primitive->config.packetFilter */
bufferSize += 4; /* CsrUint32 primitive->config.customFilter.etherType */
- bufferSize += 1; /* CsrUint8 primitive->config.customFilter.ipType */
+ bufferSize += 1; /* u8 primitive->config.customFilter.ipType */
bufferSize += 4; /* CsrUint32 primitive->config.customFilter.udpSourcePort */
bufferSize += 4; /* CsrUint32 primitive->config.customFilter.udpDestPort */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlTrafficConfigReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->trafficConfigType);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->config.packetFilter);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.etherType);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->config.customFilter.ipType);
+ CsrUint8Ser(ptr, len, (u8) primitive->config.customFilter.ipType);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.udpSourcePort);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.udpDestPort);
return(ptr);
}
-void* CsrWifiRouterCtrlTrafficConfigReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficConfigReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->trafficConfigType, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->config.packetFilter, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.etherType, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->config.customFilter.ipType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->config.customFilter.ipType, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.udpSourcePort, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.udpDestPort, buffer, &offset);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 4; /* CsrUint32 primitive->dataLength */
- bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlWifiOnReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnReq));
CsrSize offset;
CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
- primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
}
else
CsrUint16 i1;
for (i1 = 0; i1 < 2; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->stationMacAddress[i1].a[6] */
+ bufferSize += 6; /* u8 primitive->stationMacAddress[i1].a[6] */
}
}
bufferSize += 4; /* CsrUint32 primitive->smeVersions.firmwarePatch */
}
-CsrUint8* CsrWifiRouterCtrlWifiOnResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *)msg;
*len = 0;
CsrUint32Ser(ptr, len, (CsrUint32) primitive->smeVersions.firmwarePatch);
CsrCharStringSer(ptr, len, primitive->smeVersions.smeBuild);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->smeVersions.smeHip);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scheduledInterrupt);
+ CsrUint8Ser(ptr, len, (u8) primitive->scheduledInterrupt);
return(ptr);
}
-void* CsrWifiRouterCtrlWifiOnResDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnRes));
CsrSize offset;
CsrUint32Des((CsrUint32 *) &primitive->smeVersions.firmwarePatch, buffer, &offset);
CsrCharStringDes(&primitive->smeVersions.smeBuild, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->smeVersions.smeHip, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scheduledInterrupt, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scheduledInterrupt, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiRouterCtrlM4TransmitReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlM4TransmitReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4TransmitReq));
CsrSize offset;
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
- bufferSize += 6; /* CsrUint8 primitive->bssid.a[6] */
+ bufferSize += 6; /* u8 primitive->bssid.a[6] */
bufferSize += 1; /* CsrBool primitive->protection */
bufferSize += 1; /* CsrBool primitive->intraBssDistEnabled */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlModeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->mode);
+ CsrUint8Ser(ptr, len, (u8) primitive->mode);
CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->protection);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->intraBssDistEnabled);
+ CsrUint8Ser(ptr, len, (u8) primitive->protection);
+ CsrUint8Ser(ptr, len, (u8) primitive->intraBssDistEnabled);
return(ptr);
}
-void* CsrWifiRouterCtrlModeSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlModeSetReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->mode, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->protection, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->intraBssDistEnabled, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->protection, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->intraBssDistEnabled, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 2; /* CsrUint16 primitive->associationId */
bufferSize += 1; /* CsrBool primitive->staInfo.wmmOrQosEnabled */
bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->staInfo.powersaveMode */
- bufferSize += 1; /* CsrUint8 primitive->staInfo.maxSpLength */
+ bufferSize += 1; /* u8 primitive->staInfo.maxSpLength */
bufferSize += 2; /* CsrUint16 primitive->staInfo.listenIntervalInTus */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlPeerAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
CsrUint16Ser(ptr, len, (CsrUint16) primitive->associationId);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->staInfo.wmmOrQosEnabled);
+ CsrUint8Ser(ptr, len, (u8) primitive->staInfo.wmmOrQosEnabled);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->staInfo.powersaveMode);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->staInfo.maxSpLength);
+ CsrUint8Ser(ptr, len, (u8) primitive->staInfo.maxSpLength);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->staInfo.listenIntervalInTus);
return(ptr);
}
-void* CsrWifiRouterCtrlPeerAddReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerAddReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
CsrUint16Des((CsrUint16 *) &primitive->associationId, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->staInfo.wmmOrQosEnabled, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->staInfo.wmmOrQosEnabled, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->staInfo.powersaveMode, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->staInfo.maxSpLength, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->staInfo.maxSpLength, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->staInfo.listenIntervalInTus, buffer, &offset);
return primitive;
}
-CsrUint8* CsrWifiRouterCtrlPeerDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlPeerDelReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerDelReq));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlPeerUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlPeerUpdateReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerUpdateReq));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->macAddress.a[6] */
bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
bufferSize += 2; /* CsrUint16 primitive->bufferSize */
}
-CsrUint8* CsrWifiRouterCtrlBlockAckEnableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficStreamID);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->role);
+ 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);
}
-void* CsrWifiRouterCtrlBlockAckEnableReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckEnableReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->trafficStreamID, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->role, buffer, &offset);
+ 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);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
- bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->macAddress.a[6] */
bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlBlockAckDisableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficStreamID);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->role);
+ CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
+ CsrUint8Ser(ptr, len, (u8) primitive->role);
return(ptr);
}
-void* CsrWifiRouterCtrlBlockAckDisableReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckDisableReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->trafficStreamID, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->role, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrUint16 primitive->signalLength */
- bufferSize += primitive->signalLength; /* CsrUint8 primitive->signal */
+ bufferSize += primitive->signalLength; /* u8 primitive->signal */
bufferSize += 2; /* CsrUint16 primitive->dataLength */
- bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlWapiRxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlWapiRxPktReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiRxPktReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->signalLength, buffer, &offset);
if (primitive->signalLength)
{
- primitive->signal = (CsrUint8 *)CsrPmemAlloc(primitive->signalLength);
+ primitive->signal = (u8 *)CsrPmemAlloc(primitive->signalLength);
CsrMemCpyDes(primitive->signal, buffer, &offset, ((CsrUint16) (primitive->signalLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
- primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
}
else
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrUint16 primitive->dataLength */
- bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxPktReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
- primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
}
else
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
bufferSize += 2; /* CsrUint16 primitive->mlmeCommandLength */
- bufferSize += primitive->mlmeCommandLength; /* CsrUint8 primitive->mlmeCommand */
+ bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
bufferSize += 2; /* CsrUint16 primitive->dataRef1Length */
- bufferSize += primitive->dataRef1Length; /* CsrUint8 primitive->dataRef1 */
+ bufferSize += primitive->dataRef1Length; /* u8 primitive->dataRef1 */
bufferSize += 2; /* CsrUint16 primitive->dataRef2Length */
- bufferSize += primitive->dataRef2Length; /* CsrUint8 primitive->dataRef2 */
+ bufferSize += primitive->dataRef2Length; /* u8 primitive->dataRef2 */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlHipIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlHipIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlHipInd));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->mlmeCommandLength, buffer, &offset);
if (primitive->mlmeCommandLength)
{
- primitive->mlmeCommand = (CsrUint8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
+ primitive->mlmeCommand = (u8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((CsrUint16) (primitive->mlmeCommandLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->dataRef1Length, buffer, &offset);
if (primitive->dataRef1Length)
{
- primitive->dataRef1 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef1Length);
+ primitive->dataRef1 = (u8 *)CsrPmemAlloc(primitive->dataRef1Length);
CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((CsrUint16) (primitive->dataRef1Length)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->dataRef2Length, buffer, &offset);
if (primitive->dataRef2Length)
{
- primitive->dataRef2 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef2Length);
+ primitive->dataRef2 = (u8 *)CsrPmemAlloc(primitive->dataRef2Length);
CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((CsrUint16) (primitive->dataRef2Length)));
}
else
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
- bufferSize += 1; /* CsrUint8 primitive->setAddressesCount */
+ bufferSize += 1; /* u8 primitive->setAddressesCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->setAddresses[i1].a[6] */
+ bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlMulticastAddressIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->setAddressesCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->action);
+ CsrUint8Ser(ptr, len, (u8) primitive->setAddressesCount);
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
}
-void* CsrWifiRouterCtrlMulticastAddressIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMulticastAddressInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->setAddressesCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->setAddressesCount, buffer, &offset);
primitive->setAddresses = NULL;
if (primitive->setAddressesCount)
{
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->macAddress.a[6] */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlPortConfigureCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlPortConfigureCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPortConfigureCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlSuspendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->hardSuspend);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->d3Suspend);
+ CsrUint8Ser(ptr, len, (u8) primitive->hardSuspend);
+ CsrUint8Ser(ptr, len, (u8) primitive->d3Suspend);
return(ptr);
}
-void* CsrWifiRouterCtrlSuspendIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlSuspendInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->hardSuspend, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->d3Suspend, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->hardSuspend, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->d3Suspend, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiRouterCtrlTclasAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlTclasAddCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasAddCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioDeinitialiseCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioInitialiseCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlTclasDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlTclasDelCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasDelCfm));
CsrSize offset;
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrWifiRouterCtrlTrafficPacketType primitive->packetType */
bufferSize += 2; /* CsrWifiRouterCtrlProtocolDirection primitive->direction */
- bufferSize += 6; /* CsrUint8 primitive->srcAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->srcAddress.a[6] */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlTrafficProtocolIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlTrafficProtocolIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficProtocolInd));
CsrSize offset;
bufferSize += 4; /* CsrUint32 primitive->stats.txFramesNum */
bufferSize += 4; /* CsrUint32 primitive->stats.rxBytesCount */
bufferSize += 4; /* CsrUint32 primitive->stats.txBytesCount */
- bufferSize += 11; /* CsrUint8 primitive->stats.intervals[11] */
+ bufferSize += 11; /* u8 primitive->stats.intervals[11] */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlTrafficSampleIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlTrafficSampleIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficSampleInd));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlWifiOnIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnInd));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlWifiOnCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlWifiOnCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnCfm));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlM4ReadyToSendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlM4ReadyToSendIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4ReadyToSendInd));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlM4TransmittedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlM4TransmittedIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4TransmittedInd));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 1; /* CsrBool primitive->unicastPdu */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->unicastPdu);
+ CsrUint8Ser(ptr, len, (u8) primitive->unicastPdu);
return(ptr);
}
-void* CsrWifiRouterCtrlMicFailureIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMicFailureInd));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->unicastPdu, buffer, &offset);
+ 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 += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 1; /* CsrWifiRouterCtrlPeerStatus primitive->peerStatus */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlConnectedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->peerStatus);
+ CsrUint8Ser(ptr, len, (u8) primitive->peerStatus);
return(ptr);
}
-void* CsrWifiRouterCtrlConnectedIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlConnectedInd));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->peerStatus, buffer, &offset);
+ 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 += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlPeerAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlPeerAddCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerAddCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlPeerDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlPeerDelCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerDelCfm));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlUnexpectedFrameIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlUnexpectedFrameIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlUnexpectedFrameInd));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlPeerUpdateCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlPeerUpdateCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerUpdateCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlCapabilitiesCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlCapabilitiesCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlCapabilitiesCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlBlockAckEnableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlBlockAckEnableCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckEnableCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterCtrlBlockAckDisableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlBlockAckDisableCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckDisableCfm));
CsrSize offset;
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
- bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
bufferSize += 2; /* CsrResult primitive->status */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlBlockAckErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficStreamID);
+ CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
return(ptr);
}
-void* CsrWifiRouterCtrlBlockAckErrorIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckErrorInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->trafficStreamID, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 6; /* CsrUint8 primitive->staAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->staAddress.a[6] */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlStaInactiveIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlStaInactiveIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlStaInactiveInd));
CsrSize offset;
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrUint16 primitive->signalLength */
- bufferSize += primitive->signalLength; /* CsrUint8 primitive->signal */
+ bufferSize += primitive->signalLength; /* u8 primitive->signal */
bufferSize += 2; /* CsrUint16 primitive->dataLength */
- bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiRxMicCheckInd));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->signalLength, buffer, &offset);
if (primitive->signalLength)
{
- primitive->signal = (CsrUint8 *)CsrPmemAlloc(primitive->signalLength);
+ primitive->signal = (u8 *)CsrPmemAlloc(primitive->signalLength);
CsrMemCpyDes(primitive->signal, buffer, &offset, ((CsrUint16) (primitive->signalLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
- primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
}
else
}
-CsrUint8* CsrWifiRouterCtrlModeSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->mode);
+ CsrUint8Ser(ptr, len, (u8) primitive->mode);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
return(ptr);
}
-void* CsrWifiRouterCtrlModeSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlModeSetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->mode, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
return primitive;
bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrUint16 primitive->dataLength */
- bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
-CsrUint8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *)msg;
*len = 0;
}
-void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxEncryptInd));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
- primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
}
else
extern void CsrWifiRouterCtrlPfree(void *ptr);
-extern CsrUint8* CsrWifiRouterCtrlConfigurePowerModeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlConfigurePowerModeReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg);
#define CsrWifiRouterCtrlConfigurePowerModeReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlHipReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlHipReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlHipReqSizeof(void *msg);
extern void CsrWifiRouterCtrlHipReqSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterCtrlMediaStatusReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMediaStatusReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg);
#define CsrWifiRouterCtrlMediaStatusReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlMulticastAddressResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMulticastAddressResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg);
extern void CsrWifiRouterCtrlMulticastAddressResSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterCtrlPortConfigureReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPortConfigureReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg);
#define CsrWifiRouterCtrlPortConfigureReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlQosControlReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlQosControlReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlQosControlReqSizeof(void *msg);
#define CsrWifiRouterCtrlQosControlReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlSuspendResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlSuspendResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlSuspendResSizeof(void *msg);
#define CsrWifiRouterCtrlSuspendResSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlTclasAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasAddReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTclasAddReqSizeof(void *msg);
extern void CsrWifiRouterCtrlTclasAddReqSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterCtrlResumeResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlResumeResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg);
#define CsrWifiRouterCtrlResumeResSerFree CsrWifiRouterCtrlPfree
#define CsrWifiRouterCtrlRawSdioInitialiseReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiRouterCtrlRawSdioInitialiseReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlTclasDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasDelReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTclasDelReqSizeof(void *msg);
extern void CsrWifiRouterCtrlTclasDelReqSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterCtrlTrafficClassificationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficClassificationReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg);
#define CsrWifiRouterCtrlTrafficClassificationReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlTrafficConfigReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficConfigReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg);
#define CsrWifiRouterCtrlTrafficConfigReqSerFree CsrWifiRouterCtrlPfree
#define CsrWifiRouterCtrlWifiOffResSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiRouterCtrlWifiOffResSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWifiOnReqSizeof(void *msg);
extern void CsrWifiRouterCtrlWifiOnReqSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterCtrlWifiOnResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg);
extern void CsrWifiRouterCtrlWifiOnResSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterCtrlM4TransmitReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlM4TransmitReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg);
#define CsrWifiRouterCtrlM4TransmitReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlModeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlModeSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlModeSetReqSizeof(void *msg);
#define CsrWifiRouterCtrlModeSetReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlPeerAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerAddReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerAddReqSizeof(void *msg);
#define CsrWifiRouterCtrlPeerAddReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlPeerDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerDelReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerDelReqSizeof(void *msg);
#define CsrWifiRouterCtrlPeerDelReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlPeerUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerUpdateReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg);
#define CsrWifiRouterCtrlPeerUpdateReqSerFree CsrWifiRouterCtrlPfree
#define CsrWifiRouterCtrlCapabilitiesReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiRouterCtrlCapabilitiesReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlBlockAckEnableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckEnableReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg);
#define CsrWifiRouterCtrlBlockAckEnableReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlBlockAckDisableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckDisableReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg);
#define CsrWifiRouterCtrlBlockAckDisableReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlWapiRxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiRxPktReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg);
extern void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *msg);
#define CsrWifiRouterCtrlWapiUnicastFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
#define CsrWifiRouterCtrlWapiUnicastFilterReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg);
extern void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *msg);
#define CsrWifiRouterCtrlWapiFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
#define CsrWifiRouterCtrlWapiFilterReqSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlHipIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlHipIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlHipIndSizeof(void *msg);
extern void CsrWifiRouterCtrlHipIndSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterCtrlMulticastAddressIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMulticastAddressIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg);
extern void CsrWifiRouterCtrlMulticastAddressIndSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterCtrlPortConfigureCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPortConfigureCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg);
#define CsrWifiRouterCtrlPortConfigureCfmSerFree CsrWifiRouterCtrlPfree
#define CsrWifiRouterCtrlResumeIndSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
#define CsrWifiRouterCtrlResumeIndSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlSuspendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlSuspendIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlSuspendIndSizeof(void *msg);
#define CsrWifiRouterCtrlSuspendIndSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlTclasAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasAddCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg);
#define CsrWifiRouterCtrlTclasAddCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg);
#define CsrWifiRouterCtrlRawSdioDeinitialiseCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg);
#define CsrWifiRouterCtrlRawSdioInitialiseCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlTclasDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasDelCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg);
#define CsrWifiRouterCtrlTclasDelCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlTrafficProtocolIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficProtocolIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg);
#define CsrWifiRouterCtrlTrafficProtocolIndSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlTrafficSampleIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficSampleIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg);
#define CsrWifiRouterCtrlTrafficSampleIndSerFree CsrWifiRouterCtrlPfree
#define CsrWifiRouterCtrlWifiOffCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiRouterCtrlWifiOffCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWifiOnIndSizeof(void *msg);
extern void CsrWifiRouterCtrlWifiOnIndSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterCtrlWifiOnCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg);
#define CsrWifiRouterCtrlWifiOnCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlM4ReadyToSendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlM4ReadyToSendIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg);
#define CsrWifiRouterCtrlM4ReadyToSendIndSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlM4TransmittedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlM4TransmittedIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg);
#define CsrWifiRouterCtrlM4TransmittedIndSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMicFailureIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlMicFailureIndSizeof(void *msg);
#define CsrWifiRouterCtrlMicFailureIndSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlConnectedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlConnectedIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlConnectedIndSizeof(void *msg);
#define CsrWifiRouterCtrlConnectedIndSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlPeerAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerAddCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg);
#define CsrWifiRouterCtrlPeerAddCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlPeerDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerDelCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg);
#define CsrWifiRouterCtrlPeerDelCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlUnexpectedFrameIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlUnexpectedFrameIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg);
#define CsrWifiRouterCtrlUnexpectedFrameIndSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlPeerUpdateCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerUpdateCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg);
#define CsrWifiRouterCtrlPeerUpdateCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlCapabilitiesCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlCapabilitiesCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg);
#define CsrWifiRouterCtrlCapabilitiesCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlBlockAckEnableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckEnableCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg);
#define CsrWifiRouterCtrlBlockAckEnableCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlBlockAckDisableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckDisableCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg);
#define CsrWifiRouterCtrlBlockAckDisableCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlBlockAckErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckErrorIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg);
#define CsrWifiRouterCtrlBlockAckErrorIndSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlStaInactiveIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlStaInactiveIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg);
#define CsrWifiRouterCtrlStaInactiveIndSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg);
extern void CsrWifiRouterCtrlWapiRxMicCheckIndSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterCtrlModeSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlModeSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlModeSetCfmSizeof(void *msg);
#define CsrWifiRouterCtrlModeSetCfmSerFree CsrWifiRouterCtrlPfree
-extern CsrUint8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg);
extern void CsrWifiRouterCtrlWapiUnicastTxEncryptIndSerFree(void *msg);
CSR_WIFI_ROUTER_APP_TYPE_OTHER -
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterAppType;
+typedef u8 CsrWifiRouterAppType;
#define CSR_WIFI_ROUTER_APP_TYPE_SME ((CsrWifiRouterAppType) 0x0)
#define CSR_WIFI_ROUTER_APP_TYPE_PAL ((CsrWifiRouterAppType) 0x1)
#define CSR_WIFI_ROUTER_APP_TYPE_NME ((CsrWifiRouterAppType) 0x2)
- LLC/SNAP encapsulation
*******************************************************************************/
-typedef CsrUint8 CsrWifiRouterEncapsulation;
+typedef u8 CsrWifiRouterEncapsulation;
#define CSR_WIFI_ROUTER_ENCAPSULATION_ETHERNET ((CsrWifiRouterEncapsulation) 0x00)
#define CSR_WIFI_ROUTER_ENCAPSULATION_LLC_SNAP ((CsrWifiRouterEncapsulation) 0x01)
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 subscriptionHandle;
+ u8 subscriptionHandle;
} CsrWifiRouterMaPacketUnsubscribeReq;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 subscriptionHandle;
+ u8 subscriptionHandle;
CsrUint16 frameLength;
- CsrUint8 *frame;
+ u8 *frame;
CsrWifiRouterFrameFreeFunction freeFunction;
CsrWifiRouterPriority priority;
CsrUint32 hostTag;
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 subscriptionHandle;
+ u8 subscriptionHandle;
CsrResult result;
} CsrWifiRouterMaPacketRes;
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 subscriptionHandle;
+ u8 subscriptionHandle;
CsrResult status;
CsrUint16 allocOffset;
} CsrWifiRouterMaPacketSubscribeCfm;
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 subscriptionHandle;
+ u8 subscriptionHandle;
CsrResult result;
CsrUint16 frameLength;
- CsrUint8 *frame;
+ u8 *frame;
CsrWifiRouterFrameFreeFunction freeFunction;
CsrInt16 rssi;
CsrInt16 snr;
}
-CsrUint8* CsrWifiRouterMaPacketSubscribeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->encapsulation);
+ CsrUint8Ser(ptr, len, (u8) primitive->encapsulation);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->protocol);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->oui);
return(ptr);
}
-void* CsrWifiRouterMaPacketSubscribeReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->encapsulation, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->encapsulation, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->protocol, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->oui, buffer, &offset);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 20) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 1; /* CsrUint8 primitive->subscriptionHandle */
+ bufferSize += 1; /* u8 primitive->subscriptionHandle */
bufferSize += 2; /* CsrUint16 primitive->frameLength */
- bufferSize += primitive->frameLength; /* CsrUint8 primitive->frame */
+ bufferSize += primitive->frameLength; /* u8 primitive->frame */
bufferSize += 4; /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
bufferSize += 4; /* CsrUint32 primitive->hostTag */
}
-CsrUint8* CsrWifiRouterMaPacketReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+ CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->frameLength);
if (primitive->frameLength)
{
CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
CsrUint16Ser(ptr, len, (CsrUint16) primitive->priority);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->cfmRequested);
+ CsrUint8Ser(ptr, len, (u8) primitive->cfmRequested);
return(ptr);
}
-void* CsrWifiRouterMaPacketReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->frameLength, buffer, &offset);
if (primitive->frameLength)
{
- primitive->frame = (CsrUint8 *)CsrPmemAlloc(primitive->frameLength);
+ primitive->frame = (u8 *)CsrPmemAlloc(primitive->frameLength);
CsrMemCpyDes(primitive->frame, buffer, &offset, ((CsrUint16) (primitive->frameLength)));
}
else
offset += 4;
CsrUint16Des((CsrUint16 *) &primitive->priority, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->cfmRequested, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->cfmRequested, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 1; /* CsrUint8 primitive->subscriptionHandle */
+ bufferSize += 1; /* u8 primitive->subscriptionHandle */
bufferSize += 2; /* CsrResult primitive->result */
return bufferSize;
}
-CsrUint8* CsrWifiRouterMaPacketResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+ CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
return(ptr);
}
-void* CsrWifiRouterMaPacketResDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketRes));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
return primitive;
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 4; /* CsrUint32 primitive->hostTag */
bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
- bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
return bufferSize;
}
-CsrUint8* CsrWifiRouterMaPacketCancelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *)msg;
*len = 0;
}
-void* CsrWifiRouterMaPacketCancelReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCancelReq));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 1; /* CsrUint8 primitive->subscriptionHandle */
+ bufferSize += 1; /* u8 primitive->subscriptionHandle */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 2; /* CsrUint16 primitive->allocOffset */
return bufferSize;
}
-CsrUint8* CsrWifiRouterMaPacketSubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+ CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->allocOffset);
return(ptr);
}
-void* CsrWifiRouterMaPacketSubscribeCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->allocOffset, buffer, &offset);
}
-CsrUint8* CsrWifiRouterMaPacketUnsubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterMaPacketUnsubscribeCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketUnsubscribeCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiRouterMaPacketCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *)msg;
*len = 0;
}
-void* CsrWifiRouterMaPacketCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCfm));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 1; /* CsrUint8 primitive->subscriptionHandle */
+ bufferSize += 1; /* u8 primitive->subscriptionHandle */
bufferSize += 2; /* CsrResult primitive->result */
bufferSize += 2; /* CsrUint16 primitive->frameLength */
- bufferSize += primitive->frameLength; /* CsrUint8 primitive->frame */
+ bufferSize += primitive->frameLength; /* u8 primitive->frame */
bufferSize += 4; /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
bufferSize += 2; /* CsrInt16 primitive->rssi */
bufferSize += 2; /* CsrInt16 primitive->snr */
}
-CsrUint8* CsrWifiRouterMaPacketIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+ CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->frameLength);
if (primitive->frameLength)
}
-void* CsrWifiRouterMaPacketIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketIndDes(u8 *buffer, CsrSize length)
{
CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->frameLength, buffer, &offset);
if (primitive->frameLength)
{
- primitive->frame = (CsrUint8 *)CsrPmemAlloc(primitive->frameLength);
+ primitive->frame = (u8 *)CsrPmemAlloc(primitive->frameLength);
CsrMemCpyDes(primitive->frame, buffer, &offset, ((CsrUint16) (primitive->frameLength)));
}
else
extern void CsrWifiRouterPfree(void *ptr);
-extern CsrUint8* CsrWifiRouterMaPacketSubscribeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketSubscribeReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg);
#define CsrWifiRouterMaPacketSubscribeReqSerFree CsrWifiRouterPfree
#define CsrWifiRouterMaPacketUnsubscribeReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
#define CsrWifiRouterMaPacketUnsubscribeReqSerFree CsrWifiRouterPfree
-extern CsrUint8* CsrWifiRouterMaPacketReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg);
extern void CsrWifiRouterMaPacketReqSerFree(void *msg);
-extern CsrUint8* CsrWifiRouterMaPacketResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketResSizeof(void *msg);
#define CsrWifiRouterMaPacketResSerFree CsrWifiRouterPfree
-extern CsrUint8* CsrWifiRouterMaPacketCancelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketCancelReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg);
#define CsrWifiRouterMaPacketCancelReqSerFree CsrWifiRouterPfree
-extern CsrUint8* CsrWifiRouterMaPacketSubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketSubscribeCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg);
#define CsrWifiRouterMaPacketSubscribeCfmSerFree CsrWifiRouterPfree
-extern CsrUint8* CsrWifiRouterMaPacketUnsubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketUnsubscribeCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg);
#define CsrWifiRouterMaPacketUnsubscribeCfmSerFree CsrWifiRouterPfree
-extern CsrUint8* CsrWifiRouterMaPacketCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg);
#define CsrWifiRouterMaPacketCfmSerFree CsrWifiRouterPfree
-extern CsrUint8* CsrWifiRouterMaPacketIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg);
extern void CsrWifiRouterMaPacketIndSerFree(void *msg);
}
}
-void CsrWifiRouterTransportRecv(unifi_priv_t *priv, CsrUint8* buffer, CsrSize bufferLength)
+void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLength)
{
CsrMsgConvMsgEntry* msgEntry;
CsrUint16 primType;
CsrSize msgSize;
CsrSize encodeBufferLen = 0;
CsrSize offset = 0;
- CsrUint8* encodeBuffer;
+ u8* encodeBuffer;
unifi_trace(drvpriv, UDBG4, "CsrWifiRouterTransportSerialiseAndSend: primType=0x%.4X, msgType=0x%.4X\n",
primType, evt->type);
#include "csr_wifi_msgconv.h"
#include "csr_wifi_lib.h"
-void CsrUint24Des(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint24Des(CsrUint32 *v, u8 *buffer, CsrSize *offset)
{
CsrUint32 val;
/* Big endian :e.g WSC, TCLAS */
-void CsrUint16DesBigEndian(CsrUint16 *v, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint16DesBigEndian(CsrUint16 *v, u8 *buffer, CsrSize *offset)
{
CsrUint16 val;
}
-void CsrUint24DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint24DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset)
{
CsrUint32 val;
}
-void CsrUint32DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint32DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset)
{
CsrUint32 val;
}
-void CsrUint24Ser(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
+void CsrUint24Ser(u8 *ptr, CsrSize *len, CsrUint32 v)
{
- ptr[(*len) + 2] = (CsrUint8)((v & 0x00ff0000) >> 16);
- ptr[(*len) + 1] = (CsrUint8)((v & 0x0000ff00) >> 8);
- ptr[(*len)] = (CsrUint8)((v & 0x000000ff));
+ ptr[(*len) + 2] = (u8)((v & 0x00ff0000) >> 16);
+ ptr[(*len) + 1] = (u8)((v & 0x0000ff00) >> 8);
+ ptr[(*len)] = (u8)((v & 0x000000ff));
*len += 3;
}
/* Big endian :e.g WSC, TCLAS */
-void CsrUint16SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint16 v)
+void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, CsrUint16 v)
{
- ptr[(*len)] = (CsrUint8)((v & 0xff00) >> 8);
- ptr[(*len) + 1] = (CsrUint8)((v & 0x00ff));
+ ptr[(*len)] = (u8)((v & 0xff00) >> 8);
+ ptr[(*len) + 1] = (u8)((v & 0x00ff));
*len += 2;
}
-void CsrUint32SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
+void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v)
{
- ptr[(*len)] = (CsrUint8)((v & 0xff000000) >> 24);
- ptr[(*len) + 1] = (CsrUint8)((v & 0x00ff0000) >> 16);
- ptr[(*len) + 2] = (CsrUint8)((v & 0x0000ff00) >> 8);
- ptr[(*len) + 3] = (CsrUint8)((v & 0x000000ff));
+ ptr[(*len)] = (u8)((v & 0xff000000) >> 24);
+ ptr[(*len) + 1] = (u8)((v & 0x00ff0000) >> 16);
+ ptr[(*len) + 2] = (u8)((v & 0x0000ff00) >> 8);
+ ptr[(*len) + 3] = (u8)((v & 0x000000ff));
*len += 4;
}
-void CsrUint24SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
+void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v)
{
- ptr[(*len)] = (CsrUint8)((v & 0x00ff0000) >> 16);
- ptr[(*len) + 1] = (CsrUint8)((v & 0x0000ff00) >> 8);
- ptr[(*len) + 2] = (CsrUint8)((v & 0x000000ff));
+ ptr[(*len)] = (u8)((v & 0x00ff0000) >> 16);
+ ptr[(*len) + 1] = (u8)((v & 0x0000ff00) >> 8);
+ ptr[(*len) + 2] = (u8)((v & 0x000000ff));
*len += 3;
}
}
EXPORT_SYMBOL_GPL(CsrWifiEventSizeof);
-CsrUint8* CsrWifiEventSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *)msg;
*len = 0;
}
EXPORT_SYMBOL_GPL(CsrWifiEventSer);
-void* CsrWifiEventDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiEventDes(u8 *buffer, CsrSize length)
{
CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *) CsrPmemAlloc(sizeof(CsrWifiFsmEvent));
CsrSize offset = 0;
}
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Sizeof);
-CsrUint8* CsrWifiEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *)msg;
*len = 0;
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Ser);
-void* CsrWifiEventCsrUint8Des(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint8Des(u8 *buffer, CsrSize length)
{
CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint8));
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Sizeof);
-CsrUint8* CsrWifiEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *)msg;
*len = 0;
}
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Ser);
-void* CsrWifiEventCsrUint16Des(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint16Des(u8 *buffer, CsrSize length)
{
CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16));
}
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Sizeof);
-CsrUint8* CsrWifiEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *)msg;
*len = 0;
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Ser);
-void* CsrWifiEventCsrUint32Des(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint32Des(u8 *buffer, CsrSize length)
{
CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint32));
}
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Sizeof);
-CsrUint8* CsrWifiEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *)msg;
*len = 0;
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Ser);
-void* CsrWifiEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length)
{
CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16CsrUint8));
CSR_WIFI_AP_ACCESS_TYPE_DENY - Disallow if MAC address is from the list
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApAccessType;
+typedef u8 CsrWifiSmeApAccessType;
#define CSR_WIFI_AP_ACCESS_TYPE_NONE ((CsrWifiSmeApAccessType) 0x00)
#define CSR_WIFI_AP_ACCESS_TYPE_ALLOW ((CsrWifiSmeApAccessType) 0x01)
#define CSR_WIFI_AP_ACCESS_TYPE_DENY ((CsrWifiSmeApAccessType) 0x02)
CSR_WIFI_SME_AUTH_WAPIPSK - WAPI-PSK Support
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApAuthSupport;
+typedef u8 CsrWifiSmeApAuthSupport;
#define CSR_WIFI_SME_RSN_AUTH_WPAPSK ((CsrWifiSmeApAuthSupport) 0x01)
#define CSR_WIFI_SME_RSN_AUTH_WPA2PSK ((CsrWifiSmeApAuthSupport) 0x02)
#define CSR_WIFI_SME_AUTH_WAPIPSK ((CsrWifiSmeApAuthSupport) 0x04)
- WEP authentication. This can be either open or shared key
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApAuthType;
+typedef u8 CsrWifiSmeApAuthType;
#define CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM ((CsrWifiSmeApAuthType) 0x00)
#define CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL ((CsrWifiSmeApAuthType) 0x01)
#define CSR_WIFI_SME_AP_AUTH_TYPE_WEP ((CsrWifiSmeApAuthType) 0x02)
CSR_WIFI_AP_DIRECTION_ORIGINATOR - Originator
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApDirection;
+typedef u8 CsrWifiSmeApDirection;
#define CSR_WIFI_AP_DIRECTION_RECEIPIENT ((CsrWifiSmeApDirection) 0x00)
#define CSR_WIFI_AP_DIRECTION_ORIGINATOR ((CsrWifiSmeApDirection) 0x01)
CSR_WIFI_SME_AP_PHY_SUPPORT_N - 802.11n
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApPhySupport;
+typedef u8 CsrWifiSmeApPhySupport;
#define CSR_WIFI_SME_AP_PHY_SUPPORT_A ((CsrWifiSmeApPhySupport) 0x01)
#define CSR_WIFI_SME_AP_PHY_SUPPORT_B ((CsrWifiSmeApPhySupport) 0x02)
#define CSR_WIFI_SME_AP_PHY_SUPPORT_G ((CsrWifiSmeApPhySupport) 0x04)
CSR_WIFI_AP_TYPE_P2P - P2P Group Owner(GO)
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApType;
+typedef u8 CsrWifiSmeApType;
#define CSR_WIFI_AP_TYPE_LEGACY ((CsrWifiSmeApType) 0x00)
#define CSR_WIFI_AP_TYPE_P2P ((CsrWifiSmeApType) 0x01)
See CsrWifiSmeApAuthSupport for bit definitions
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApAuthSupportMask;
+typedef u8 CsrWifiSmeApAuthSupportMask;
/*******************************************************************************
NAME
Mask type for use with the values defined by CsrWifiSmeApPhySupport
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApPhySupportMask;
+typedef u8 CsrWifiSmeApPhySupportMask;
/*******************************************************************************
NAME
{
CsrBool greenfieldSupported;
CsrBool shortGi20MHz;
- CsrUint8 rxStbc;
+ u8 rxStbc;
CsrBool rifsModeAllowed;
- CsrUint8 htProtection;
+ u8 htProtection;
CsrBool dualCtsProtection;
} CsrWifiSmeApHtParams;
*******************************************************************************/
typedef struct
{
- CsrUint8 operatingClass;
- CsrUint8 operatingChannelCount;
- CsrUint8 *operatingChannel;
+ u8 operatingClass;
+ u8 operatingChannelCount;
+ u8 *operatingChannel;
} CsrWifiSmeApP2pOperatingChanEntry;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint8 country[3];
- CsrUint8 channelEntryListCount;
+ u8 country[3];
+ u8 channelEntryListCount;
CsrWifiSmeApP2pOperatingChanEntry *channelEntryList;
} CsrWifiSmeApP2pOperatingChanList;
typedef struct
{
CsrWifiMacAddress peerMacAddress;
- CsrUint8 tid;
+ u8 tid;
CsrWifiSmeApDirection direction;
} CsrWifiSmeApBaSession;
{
CsrWifiSmeApPhySupportMask phySupportedBitmap;
CsrUint16 beaconInterval;
- CsrUint8 dtimPeriod;
+ u8 dtimPeriod;
CsrUint16 maxListenInterval;
- CsrUint8 supportedRatesCount;
- CsrUint8 supportedRates[20];
+ u8 supportedRatesCount;
+ u8 supportedRates[20];
CsrWifiSmePreambleType preamble;
CsrBool shortSlotTimeEnabled;
CsrWifiSmeCtsProtectionType ctsProtectionType;
CsrWifiSmeWmmAcParams wmmApParams[4];
CsrWifiSmeWmmAcParams wmmApBcParams[4];
CsrWifiSmeApAccessType accessType;
- CsrUint8 macAddressListCount;
+ u8 macAddressListCount;
CsrWifiMacAddress *macAddressList;
CsrWifiSmeApHtParams apHtParams;
} CsrWifiSmeApMacConfig;
CsrWifiSmeP2pGroupCapabilityMask groupCapability;
CsrWifiSmeApP2pOperatingChanList operatingChanList;
CsrBool opPsEnabled;
- CsrUint8 ctWindow;
+ u8 ctWindow;
CsrWifiSmeP2pNoaConfigMethod noaConfigMethod;
CsrBool allowNoaWithNonP2pDevices;
} CsrWifiSmeApP2pGoConfig;
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 initialPresence;
+ u8 initialPresence;
CsrWifiSmeApType apType;
CsrBool cloakSsid;
CsrWifiSsid ssid;
CsrWifiSmeRadioIF ifIndex;
- CsrUint8 channel;
- CsrUint8 maxConnections;
+ u8 channel;
+ u8 maxConnections;
CsrWifiSmeApSecConfig apCredentials;
CsrWifiSmeApMacConfig smeApConfig;
CsrWifiSmeApP2pGoConfig p2pGoParam;
CsrUint16 interfaceTag;
CsrResult status;
CsrUint16 secIeLength;
- CsrUint8 *secIe;
+ u8 *secIe;
} CsrWifiSmeApBeaconingStartCfm;
/*******************************************************************************
CsrWifiSmeIEEE80211Reason disassocReason;
CsrWifiSmeIEEE80211Reason deauthReason;
CsrWifiSmeWpsRegistration WpsRegistration;
- CsrUint8 secIeLength;
- CsrUint8 *secIe;
- CsrUint8 groupKeyId;
+ u8 secIeLength;
+ u8 *secIe;
+ u8 groupKeyId;
CsrUint16 seqNumber[8];
} CsrWifiSmeApStaNotifyInd;
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_CFM, dst__, src__); \
msg__->status = (status__); \
msg__->numInterfaces = (numInterfaces__); \
- CsrMemCpy(msg__->capBitmap, (capBitmap__), sizeof(CsrUint8) * 2);
+ CsrMemCpy(msg__->capBitmap, (capBitmap__), sizeof(u8) * 2);
#define CsrWifiSmeInterfaceCapabilityGetCfmSendTo(dst__, src__, status__, numInterfaces__, capBitmap__) \
{ \
- Automatic
*******************************************************************************/
-typedef CsrUint8 CsrWifiSme80211NetworkType;
+typedef u8 CsrWifiSme80211NetworkType;
#define CSR_WIFI_SME_80211_NETWORK_TYPE_DS ((CsrWifiSme80211NetworkType) 0x00)
#define CSR_WIFI_SME_80211_NETWORK_TYPE_OFDM24 ((CsrWifiSme80211NetworkType) 0x01)
#define CSR_WIFI_SME_80211_NETWORK_TYPE_OFDM5 ((CsrWifiSme80211NetworkType) 0x02)
- Privacy mode is disabled
*******************************************************************************/
-typedef CsrUint8 CsrWifiSme80211PrivacyMode;
+typedef u8 CsrWifiSme80211PrivacyMode;
#define CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED ((CsrWifiSme80211PrivacyMode) 0x00)
#define CSR_WIFI_SME_80211_PRIVACY_MODE_ENABLED ((CsrWifiSme80211PrivacyMode) 0x01)
network
*******************************************************************************/
-typedef CsrUint8 CsrWifiSme80211dTrustLevel;
+typedef u8 CsrWifiSme80211dTrustLevel;
#define CSR_WIFI_SME_80211D_TRUST_LEVEL_STRICT ((CsrWifiSme80211dTrustLevel) 0x01)
#define CSR_WIFI_SME_80211D_TRUST_LEVEL_ADJUNCT ((CsrWifiSme80211dTrustLevel) 0x02)
#define CSR_WIFI_SME_80211D_TRUST_LEVEL_BSS ((CsrWifiSme80211dTrustLevel) 0x03)
CSR_WIFI_SME_AMP_INACTIVE - AMP INACTIVE
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeAmpStatus;
+typedef u8 CsrWifiSmeAmpStatus;
#define CSR_WIFI_SME_AMP_ACTIVE ((CsrWifiSmeAmpStatus) 0x00)
#define CSR_WIFI_SME_AMP_INACTIVE ((CsrWifiSmeAmpStatus) 0x01)
- Not connected
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeBasicUsability;
+typedef u8 CsrWifiSmeBasicUsability;
#define CSR_WIFI_SME_BASIC_USABILITY_UNUSABLE ((CsrWifiSmeBasicUsability) 0x00)
#define CSR_WIFI_SME_BASIC_USABILITY_POOR ((CsrWifiSmeBasicUsability) 0x01)
#define CSR_WIFI_SME_BASIC_USABILITY_SATISFACTORY ((CsrWifiSmeBasicUsability) 0x02)
- Specifies P2P
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeBssType;
+typedef u8 CsrWifiSmeBssType;
#define CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE ((CsrWifiSmeBssType) 0x00)
#define CSR_WIFI_SME_BSS_TYPE_ADHOC ((CsrWifiSmeBssType) 0x01)
#define CSR_WIFI_SME_BSS_TYPE_ANY_BSS ((CsrWifiSmeBssType) 0x02)
- Packet Traffic Arbitrator coexistence signalling
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeCoexScheme;
+typedef u8 CsrWifiSmeCoexScheme;
#define CSR_WIFI_SME_COEX_SCHEME_DISABLED ((CsrWifiSmeCoexScheme) 0x00)
#define CSR_WIFI_SME_COEX_SCHEME_CSR ((CsrWifiSmeCoexScheme) 0x01)
#define CSR_WIFI_SME_COEX_SCHEME_CSR_CHANNEL ((CsrWifiSmeCoexScheme) 0x02)
application has sent CSR_WIFI_SME_WIFI_OFF_REQ
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeControlIndication;
+typedef u8 CsrWifiSmeControlIndication;
#define CSR_WIFI_SME_CONTROL_INDICATION_ERROR ((CsrWifiSmeControlIndication) 0x01)
#define CSR_WIFI_SME_CONTROL_INDICATION_EXIT ((CsrWifiSmeControlIndication) 0x02)
#define CSR_WIFI_SME_CONTROL_INDICATION_USER_REQUESTED ((CsrWifiSmeControlIndication) 0x03)
this option specifies the same behaviour as AUTOMATIC
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeCtsProtectionType;
+typedef u8 CsrWifiSmeCtsProtectionType;
#define CSR_WIFI_SME_CTS_PROTECTION_AUTOMATIC ((CsrWifiSmeCtsProtectionType) 0x00)
#define CSR_WIFI_SME_CTS_PROTECTION_FORCE_ENABLED ((CsrWifiSmeCtsProtectionType) 0x01)
#define CSR_WIFI_SME_CTS_PROTECTION_FORCE_DISABLED ((CsrWifiSmeCtsProtectionType) 0x02)
CURRENTLY NOT SUPPORTED
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeD3AutoScanMode;
+typedef u8 CsrWifiSmeD3AutoScanMode;
#define CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSON ((CsrWifiSmeD3AutoScanMode) 0x00)
#define CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSOFF ((CsrWifiSmeD3AutoScanMode) 0x01)
#define CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSAUTO ((CsrWifiSmeD3AutoScanMode) 0x02)
- Preformated IEEE 802.11 header for user plane
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeFirmwareDriverInterface;
+typedef u8 CsrWifiSmeFirmwareDriverInterface;
#define CSR_WIFI_SME_FIRMWARE_DRIVER_INTERFACE_UNIT_DATA_INTERFACE ((CsrWifiSmeFirmwareDriverInterface) 0x00)
#define CSR_WIFI_SME_FIRMWARE_DRIVER_INTERFACE_PACKET_INTERFACE ((CsrWifiSmeFirmwareDriverInterface) 0x01)
- For future use.
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeHostPowerMode;
+typedef u8 CsrWifiSmeHostPowerMode;
#define CSR_WIFI_SME_HOST_POWER_MODE_ACTIVE ((CsrWifiSmeHostPowerMode) 0x00)
#define CSR_WIFI_SME_HOST_POWER_MODE_POWER_SAVE ((CsrWifiSmeHostPowerMode) 0x01)
#define CSR_WIFI_SME_HOST_POWER_MODE_FULL_POWER_SAVE ((CsrWifiSmeHostPowerMode) 0x02)
CSR_WIFI_SME_KEY_TYPE_CCKM - Key for Cisco Centralized Key Management
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeKeyType;
+typedef u8 CsrWifiSmeKeyType;
#define CSR_WIFI_SME_KEY_TYPE_GROUP ((CsrWifiSmeKeyType) 0x00)
#define CSR_WIFI_SME_KEY_TYPE_PAIRWISE ((CsrWifiSmeKeyType) 0x01)
#define CSR_WIFI_SME_KEY_TYPE_STAKEY ((CsrWifiSmeKeyType) 0x02)
CSR_WIFI_SME_LIST_ACTION_FLUSH - Remove all items
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeListAction;
+typedef u8 CsrWifiSmeListAction;
#define CSR_WIFI_SME_LIST_ACTION_GET ((CsrWifiSmeListAction) 0x00)
#define CSR_WIFI_SME_LIST_ACTION_ADD ((CsrWifiSmeListAction) 0x01)
#define CSR_WIFI_SME_LIST_ACTION_REMOVE ((CsrWifiSmeListAction) 0x02)
station has disconnected from the AP
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeMediaStatus;
+typedef u8 CsrWifiSmeMediaStatus;
#define CSR_WIFI_SME_MEDIA_STATUS_CONNECTED ((CsrWifiSmeMediaStatus) 0x00)
#define CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED ((CsrWifiSmeMediaStatus) 0x01)
otherwise.
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pCapability;
+typedef u8 CsrWifiSmeP2pCapability;
#define CSR_WIFI_SME_P2P_SERVICE_DISCOVERY_CAPABILITY ((CsrWifiSmeP2pCapability) 0x01)
#define CSR_WIFI_SME_P2P_CLIENT_DISCOVERABILITY_CAPABILITY ((CsrWifiSmeP2pCapability) 0x02)
#define CSR_WIFI_SME_P2P_CONCURRENT_OPERATION_CAPABILITY ((CsrWifiSmeP2pCapability) 0x04)
- Support of persistent reconnect
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pGroupCapability;
+typedef u8 CsrWifiSmeP2pGroupCapability;
#define CSR_WIFI_P2P_GRP_CAP_GO ((CsrWifiSmeP2pGroupCapability) 0x01)
#define CSR_WIFI_P2P_GRP_CAP_PERSISTENT ((CsrWifiSmeP2pGroupCapability) 0x02)
#define CSR_WIFI_P2P_GRP_CAP_INTRABSS_DIST ((CsrWifiSmeP2pGroupCapability) 0x08)
CSR_WIFI_P2P_NOA_USER_DEFINED - NOA as specified by the user
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pNoaConfigMethod;
+typedef u8 CsrWifiSmeP2pNoaConfigMethod;
#define CSR_WIFI_P2P_NOA_NONE ((CsrWifiSmeP2pNoaConfigMethod) 0x00)
#define CSR_WIFI_P2P_NOA_AUTONOMOUS ((CsrWifiSmeP2pNoaConfigMethod) 0x01)
#define CSR_WIFI_P2P_NOA_USER_DEFINED ((CsrWifiSmeP2pNoaConfigMethod) 0x02)
within a P2P Group
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pRole;
+typedef u8 CsrWifiSmeP2pRole;
#define CSR_WIFI_SME_P2P_ROLE_NONE ((CsrWifiSmeP2pRole) 0x00)
#define CSR_WIFI_SME_P2P_ROLE_STANDALONE ((CsrWifiSmeP2pRole) 0x01)
#define CSR_WIFI_SME_P2P_ROLE_GO ((CsrWifiSmeP2pRole) 0x02)
- Fail; Status Reserved
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pStatus;
+typedef u8 CsrWifiSmeP2pStatus;
#define CSR_WIFI_SME_P2P_STATUS_SUCCESS ((CsrWifiSmeP2pStatus) 0x00)
#define CSR_WIFI_SME_P2P_STATUS_FAIL_INFO_UNAVAILABLE ((CsrWifiSmeP2pStatus) 0x01)
#define CSR_WIFI_SME_P2P_STATUS_FAIL_INCOMPATIBLE_PARAM ((CsrWifiSmeP2pStatus) 0x02)
match at least one of the specified TCLAS IEs.
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmePacketFilterMode;
+typedef u8 CsrWifiSmePacketFilterMode;
#define CSR_WIFI_SME_PACKET_FILTER_MODE_OPT_OUT ((CsrWifiSmePacketFilterMode) 0x00)
#define CSR_WIFI_SME_PACKET_FILTER_MODE_OPT_IN ((CsrWifiSmePacketFilterMode) 0x03)
analysis
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmePowerSaveLevel;
+typedef u8 CsrWifiSmePowerSaveLevel;
#define CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW ((CsrWifiSmePowerSaveLevel) 0x00)
#define CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH ((CsrWifiSmePowerSaveLevel) 0x01)
#define CSR_WIFI_SME_POWER_SAVE_LEVEL_MED ((CsrWifiSmePowerSaveLevel) 0x02)
CSR_WIFI_SME_USE_SHORT_PREAMBLE - Use short PPDU format
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmePreambleType;
+typedef u8 CsrWifiSmePreambleType;
#define CSR_WIFI_SME_USE_LONG_PREAMBLE ((CsrWifiSmePreambleType) 0x00)
#define CSR_WIFI_SME_USE_SHORT_PREAMBLE ((CsrWifiSmePreambleType) 0x01)
CSR_WIFI_SME_RADIO_IF_BOTH - Future use: currently not supported
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeRadioIF;
+typedef u8 CsrWifiSmeRadioIF;
#define CSR_WIFI_SME_RADIO_IF_GHZ_2_4 ((CsrWifiSmeRadioIF) 0x01)
#define CSR_WIFI_SME_RADIO_IF_GHZ_5_0 ((CsrWifiSmeRadioIF) 0x02)
#define CSR_WIFI_SME_RADIO_IF_BOTH ((CsrWifiSmeRadioIF) 0x03)
- See IEEE 802.11 Standard
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeRegulatoryDomain;
+typedef u8 CsrWifiSmeRegulatoryDomain;
#define CSR_WIFI_SME_REGULATORY_DOMAIN_OTHER ((CsrWifiSmeRegulatoryDomain) 0x00)
#define CSR_WIFI_SME_REGULATORY_DOMAIN_FCC ((CsrWifiSmeRegulatoryDomain) 0x10)
#define CSR_WIFI_SME_REGULATORY_DOMAIN_IC ((CsrWifiSmeRegulatoryDomain) 0x20)
- A better AP has been found
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeRoamReason;
+typedef u8 CsrWifiSmeRoamReason;
#define CSR_WIFI_SME_ROAM_REASON_BEACONLOST ((CsrWifiSmeRoamReason) 0x00)
#define CSR_WIFI_SME_ROAM_REASON_DISASSOCIATED ((CsrWifiSmeRoamReason) 0x01)
#define CSR_WIFI_SME_ROAM_REASON_DEAUTHENTICATED ((CsrWifiSmeRoamReason) 0x02)
messages
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeScanType;
+typedef u8 CsrWifiSmeScanType;
#define CSR_WIFI_SME_SCAN_TYPE_ALL ((CsrWifiSmeScanType) 0x00)
#define CSR_WIFI_SME_SCAN_TYPE_ACTIVE ((CsrWifiSmeScanType) 0x01)
#define CSR_WIFI_SME_SCAN_TYPE_PASSIVE ((CsrWifiSmeScanType) 0x02)
received each second in either direction
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeTrafficType;
+typedef u8 CsrWifiSmeTrafficType;
#define CSR_WIFI_SME_TRAFFIC_TYPE_OCCASIONAL ((CsrWifiSmeTrafficType) 0x00)
#define CSR_WIFI_SME_TRAFFIC_TYPE_BURSTY ((CsrWifiSmeTrafficType) 0x01)
#define CSR_WIFI_SME_TRAFFIC_TYPE_PERIODIC ((CsrWifiSmeTrafficType) 0x02)
- Voice traffic TSPEC
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeTspecCtrl;
+typedef u8 CsrWifiSmeTspecCtrl;
#define CSR_WIFI_SME_TSPEC_CTRL_STRICT ((CsrWifiSmeTspecCtrl) 0x01)
#define CSR_WIFI_SME_TSPEC_CTRL_CCX_SIGNALLING ((CsrWifiSmeTspecCtrl) 0x02)
#define CSR_WIFI_SME_TSPEC_CTRL_CCX_VOICE ((CsrWifiSmeTspecCtrl) 0x04)
- The AP has deleted the TSPEC
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeTspecResultCode;
+typedef u8 CsrWifiSmeTspecResultCode;
#define CSR_WIFI_SME_TSPEC_RESULT_SUCCESS ((CsrWifiSmeTspecResultCode) 0x00)
#define CSR_WIFI_SME_TSPEC_RESULT_UNSPECIFIED_QOS_FAILURE ((CsrWifiSmeTspecResultCode) 0x01)
#define CSR_WIFI_SME_TSPEC_RESULT_FAILURE ((CsrWifiSmeTspecResultCode) 0x02)
CSR_WIFI_SME_WEP_AUTH_MODE_SHARED - Shared-key WEP enabled network.
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWepAuthMode;
+typedef u8 CsrWifiSmeWepAuthMode;
#define CSR_WIFI_SME_WEP_AUTH_MODE_OPEN ((CsrWifiSmeWepAuthMode) 0x00)
#define CSR_WIFI_SME_WEP_AUTH_MODE_SHARED ((CsrWifiSmeWepAuthMode) 0x01)
- WEP 128 credential
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWepCredentialType;
+typedef u8 CsrWifiSmeWepCredentialType;
#define CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64 ((CsrWifiSmeWepCredentialType) 0x00)
#define CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128 ((CsrWifiSmeWepCredentialType) 0x01)
available WMM features.
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWmmMode;
+typedef u8 CsrWifiSmeWmmMode;
#define CSR_WIFI_SME_WMM_MODE_DISABLED ((CsrWifiSmeWmmMode) 0x00)
#define CSR_WIFI_SME_WMM_MODE_AC_ENABLED ((CsrWifiSmeWmmMode) 0x01)
#define CSR_WIFI_SME_WMM_MODE_PS_ENABLED ((CsrWifiSmeWmmMode) 0x02)
and MMPDUs) per USP
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWmmQosInfo;
+typedef u8 CsrWifiSmeWmmQosInfo;
#define CSR_WIFI_SME_WMM_QOS_INFO_AC_MAX_SP_ALL ((CsrWifiSmeWmmQosInfo) 0x00)
#define CSR_WIFI_SME_WMM_QOS_INFO_AC_VO ((CsrWifiSmeWmmQosInfo) 0x01)
#define CSR_WIFI_SME_WMM_QOS_INFO_AC_VI ((CsrWifiSmeWmmQosInfo) 0x02)
- Others.
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWpsDeviceCategory;
+typedef u8 CsrWifiSmeWpsDeviceCategory;
#define CSR_WIFI_SME_WPS_CATEGORY_UNSPECIFIED ((CsrWifiSmeWpsDeviceCategory) 0x00)
#define CSR_WIFI_SME_WPS_CATEGORY_COMPUTER ((CsrWifiSmeWpsDeviceCategory) 0x01)
#define CSR_WIFI_SME_WPS_CATEGORY_INPUT_DEV ((CsrWifiSmeWpsDeviceCategory) 0x02)
- Bar code reader.
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWpsDeviceSubCategory;
+typedef u8 CsrWifiSmeWpsDeviceSubCategory;
#define CSR_WIFI_SME_WPS_SUB_CATEGORY_UNSPECIFIED ((CsrWifiSmeWpsDeviceSubCategory) 0x00)
#define CSR_WIFI_SME_WPS_STORAGE_SUB_CATEGORY_NAS ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
#define CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_PRNTR ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
CSR_WIFI_SME_WPS_REG_UNKNOWN - No encryption set
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWpsRegistration;
+typedef u8 CsrWifiSmeWpsRegistration;
#define CSR_WIFI_SME_WPS_REG_NOT_REQUIRED ((CsrWifiSmeWpsRegistration) 0x00)
#define CSR_WIFI_SME_WPS_REG_REQUIRED ((CsrWifiSmeWpsRegistration) 0x01)
#define CSR_WIFI_SME_WPS_REG_UNKNOWN ((CsrWifiSmeWpsRegistration) 0x02)
Mask type for use with the values defined by CsrWifiSmeP2pCapability
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pCapabilityMask;
+typedef u8 CsrWifiSmeP2pCapabilityMask;
/*******************************************************************************
NAME
Mask type for use with the values defined by CsrWifiSmeP2pGroupCapability
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pGroupCapabilityMask;
+typedef u8 CsrWifiSmeP2pGroupCapabilityMask;
/*******************************************************************************
NAME
Mask type for use with the values defined by CsrWifiSmeTspecCtrl
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeTspecCtrlMask;
+typedef u8 CsrWifiSmeTspecCtrlMask;
/*******************************************************************************
NAME
Mask type for use with the values defined by CsrWifiSmeWmmMode
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWmmModeMask;
+typedef u8 CsrWifiSmeWmmModeMask;
/*******************************************************************************
NAME
Mask type for use with the values defined by CsrWifiSmeWmmQosInfo
*******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWmmQosInfoMask;
+typedef u8 CsrWifiSmeWmmQosInfoMask;
/*******************************************************************************
NAME
*******************************************************************************/
typedef struct
{
- CsrUint8 listenChannel;
+ u8 listenChannel;
CsrUint16 availabilityDuration;
CsrUint16 avalabilityPeriod;
} CsrWifiSmeAvailabilityConfig;
*******************************************************************************/
typedef struct
{
- CsrUint8 keepAliveTimeMs;
+ u8 keepAliveTimeMs;
CsrBool apRoamingEnabled;
- CsrUint8 measurementsMask;
+ u8 measurementsMask;
CsrBool ccxRadioMgtEnabled;
} CsrWifiSmeCcxConfig;
*******************************************************************************/
typedef struct
{
- CsrUint8 unifiTxDataRate;
- CsrUint8 unifiRxDataRate;
+ u8 unifiTxDataRate;
+ u8 unifiRxDataRate;
CsrUint32 dot11RetryCount;
CsrUint32 dot11MultipleRetryCount;
CsrUint32 dot11AckFailureCount;
typedef struct
{
CsrUint16 length;
- CsrUint8 *data;
+ u8 *data;
} CsrWifiSmeDataBlock;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint8 empty;
+ u8 empty;
} CsrWifiSmeEmpty;
/*******************************************************************************
typedef struct
{
CsrBool unifiFixMaxTxDataRate;
- CsrUint8 unifiFixTxDataRate;
+ u8 unifiFixTxDataRate;
CsrUint16 dot11RtsThreshold;
CsrUint16 dot11FragmentationThreshold;
CsrUint16 dot11CurrentTxPowerLevel;
*******************************************************************************/
typedef struct
{
- CsrUint8 listenChannel;
+ u8 listenChannel;
CsrUint16 availabilityDuration;
CsrUint16 avalabilityPeriod;
} CsrWifiSmeP2pProfileIdentity;
typedef struct
{
CsrWifiMacAddress bssid;
- CsrUint8 pmkid[16];
+ u8 pmkid[16];
} CsrWifiSmePmkid;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint8 pmkidsCount;
+ u8 pmkidsCount;
CsrWifiSmePmkid *pmkids;
} CsrWifiSmePmkidList;
CsrBool dot11MultiDomainCapabilityImplemented;
CsrBool dot11MultiDomainCapabilityEnabled;
CsrWifiSmeRegulatoryDomain currentRegulatoryDomain;
- CsrUint8 currentCountryCode[2];
+ u8 currentCountryCode[2];
} CsrWifiSmeRegulatoryDomainInfo;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint8 data[8];
+ u8 data[8];
} CsrWifiSmeTsfTime;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint8 cwMin;
- CsrUint8 cwMax;
- CsrUint8 aifs;
+ u8 cwMin;
+ u8 cwMax;
+ u8 aifs;
CsrUint16 txopLimit;
CsrBool admissionControlMandatory;
} CsrWifiSmeWmmAcParams;
*******************************************************************************/
typedef struct
{
- CsrUint8 deviceDetails[8];
+ u8 deviceDetails[8];
} CsrWifiSmeWpsDeviceType;
/*******************************************************************************
typedef struct
{
CsrBool spportWps;
- CsrUint8 deviceType;
+ u8 deviceType;
} CsrWifiSmeWpsDeviceTypeCommon;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint8 cloakedSsidsCount;
+ u8 cloakedSsidsCount;
CsrWifiSsid *cloakedSsids;
} CsrWifiSmeCloakedSsidConfig;
CsrWifiSmeAuthModeMask authModeMask;
CsrWifiSmeEncryptionMask encryptionModeMask;
CsrUint16 mlmeAssociateReqInformationElementsLength;
- CsrUint8 *mlmeAssociateReqInformationElements;
+ u8 *mlmeAssociateReqInformationElements;
CsrWifiSmeWmmQosInfoMask wmmQosInfo;
CsrBool adhocJoinOnly;
- CsrUint8 adhocChannel;
+ u8 adhocChannel;
} CsrWifiSmeConnectionConfig;
/*******************************************************************************
CsrWifiSsid ssid;
CsrWifiMacAddress bssid;
CsrWifiSme80211NetworkType networkType80211;
- CsrUint8 channelNumber;
+ u8 channelNumber;
CsrUint16 channelFrequency;
CsrWifiSmeAuthMode authMode;
CsrWifiSmeEncryption pairwiseCipher;
CsrUint16 beaconPeriodTu;
CsrBool reassociation;
CsrUint16 beaconFrameLength;
- CsrUint8 *beaconFrame;
+ u8 *beaconFrame;
CsrUint16 associationReqFrameLength;
- CsrUint8 *associationReqFrame;
+ u8 *associationReqFrame;
CsrUint16 associationRspFrameLength;
- CsrUint8 *associationRspFrame;
+ u8 *associationRspFrame;
CsrUint16 assocScanInfoElementsLength;
- CsrUint8 *assocScanInfoElements;
+ u8 *assocScanInfoElements;
CsrUint16 assocReqCapabilities;
CsrUint16 assocReqListenIntervalTu;
CsrWifiMacAddress assocReqApAddress;
CsrUint16 assocReqInfoElementsLength;
- CsrUint8 *assocReqInfoElements;
+ u8 *assocReqInfoElements;
CsrWifiSmeIEEE80211Result assocRspResult;
CsrUint16 assocRspCapabilityInfo;
CsrUint16 assocRspAssociationId;
CsrUint16 assocRspInfoElementsLength;
- CsrUint8 *assocRspInfoElements;
+ u8 *assocRspInfoElements;
} CsrWifiSmeConnectionInfo;
/*******************************************************************************
typedef struct
{
CsrWifiSme80211dTrustLevel trustLevel;
- CsrUint8 countryCode[2];
+ u8 countryCode[2];
CsrWifiSmeFirmwareDriverInterface firmwareDriverInterface;
CsrBool enableStrictDraftN;
} CsrWifiSmeDeviceConfig;
CsrWifiSmeWpsConfigTypeMask configMethods;
CsrWifiSmeP2pCapabilityMask p2PDeviceCap;
CsrWifiSmeWpsDeviceType primDeviceType;
- CsrUint8 secondaryDeviceTypeCount;
+ u8 secondaryDeviceTypeCount;
CsrWifiSmeWpsDeviceType *secDeviceType;
- CsrUint8 deviceName[32];
- CsrUint8 deviceNameLength;
+ u8 deviceName[32];
+ u8 deviceNameLength;
} CsrWifiSmeDeviceInfo;
/*******************************************************************************
{
CsrWifiMacAddress p2pDeviceAddress;
CsrWifiSmeWpsDeviceTypeCommon primaryDeviceType;
- CsrUint8 secondaryDeviceTypesCount;
- CsrUint8 secondaryDeviceTypes[10];
- CsrUint8 deviceNameLength;
- CsrUint8 deviceName[32];
+ u8 secondaryDeviceTypesCount;
+ u8 secondaryDeviceTypes[10];
+ u8 deviceNameLength;
+ u8 deviceName[32];
} CsrWifiSmeDeviceInfoCommon;
/*******************************************************************************
typedef struct
{
CsrWifiSmeKeyType keyType;
- CsrUint8 keyIndex;
+ u8 keyIndex;
CsrBool wepTxKey;
CsrUint16 keyRsc[8];
CsrBool authenticator;
CsrWifiMacAddress address;
- CsrUint8 keyLength;
- CsrUint8 key[32];
+ u8 keyLength;
+ u8 key[32];
} CsrWifiSmeKey;
/*******************************************************************************
{
CsrWifiSmeP2pGroupCapabilityMask groupCapability;
CsrWifiMacAddress p2pDeviceAddress;
- CsrUint8 p2pClientInfoCount;
+ u8 p2pClientInfoCount;
CsrWifiSmeP2pClientInfoType *p2PClientInfo;
} CsrWifiSmeP2pGroupInfo;
CsrUint16 listenIntervalTu;
CsrBool rxDtims;
CsrWifiSmeD3AutoScanMode d3AutoScanMode;
- CsrUint8 clientTrafficWindow;
+ u8 clientTrafficWindow;
CsrBool opportunisticPowerSave;
CsrBool noticeOfAbsence;
} CsrWifiSmePowerConfig;
CsrWifiSmeRoamingBandData roamingBands[3];
CsrBool disableSmoothRoaming;
CsrBool disableRoamScans;
- CsrUint8 reconnectLimit;
+ u8 reconnectLimit;
CsrUint16 reconnectLimitIntervalMs;
CsrWifiSmeScanConfigData roamScanCfg[3];
} CsrWifiSmeRoamingConfig;
CsrInt8 lowSnrThreshold;
CsrInt8 deltaSnrThreshold;
CsrUint16 passiveChannelListCount;
- CsrUint8 *passiveChannelList;
+ u8 *passiveChannelList;
} CsrWifiSmeScanConfig;
/*******************************************************************************
CsrWifiSmeTsfTime localTime;
CsrUint16 channelFrequency;
CsrUint16 capabilityInformation;
- CsrUint8 channelNumber;
+ u8 channelNumber;
CsrWifiSmeBasicUsability usability;
CsrWifiSmeBssType bssType;
CsrUint16 informationElementsLength;
- CsrUint8 *informationElements;
+ u8 *informationElements;
CsrWifiSmeP2pRole p2pDeviceRole;
union {
CsrWifiSmeEmpty reservedCli;
*******************************************************************************/
typedef struct
{
- CsrUint8 connectionQualityRssiChangeTrigger;
- CsrUint8 connectionQualitySnrChangeTrigger;
+ u8 connectionQualityRssiChangeTrigger;
+ u8 connectionQualitySnrChangeTrigger;
CsrWifiSmeWmmModeMask wmmModeMask;
CsrWifiSmeRadioIF ifIndex;
CsrBool allowUnicastUseGroupCipher;
typedef struct
{
CsrWifiSmeWepAuthMode wepAuthType;
- CsrUint8 selectedWepKey;
- CsrUint8 key1[13];
- CsrUint8 key2[13];
- CsrUint8 key3[13];
- CsrUint8 key4[13];
+ u8 selectedWepKey;
+ u8 key1[13];
+ u8 key2[13];
+ u8 key3[13];
+ u8 key4[13];
} CsrWifiSmeWep128Keys;
/*******************************************************************************
typedef struct
{
CsrWifiSmeWepAuthMode wepAuthType;
- CsrUint8 selectedWepKey;
- CsrUint8 key1[5];
- CsrUint8 key2[5];
- CsrUint8 key3[5];
- CsrUint8 key4[5];
+ u8 selectedWepKey;
+ u8 key1[5];
+ u8 key2[5];
+ u8 key3[5];
+ u8 key4[5];
} CsrWifiSmeWep64Keys;
/*******************************************************************************
*******************************************************************************/
typedef struct
{
- CsrUint8 wpsVersion;
- CsrUint8 uuid[16];
- CsrUint8 deviceName[32];
- CsrUint8 deviceNameLength;
- CsrUint8 manufacturer[64];
- CsrUint8 manufacturerLength;
- CsrUint8 modelName[32];
- CsrUint8 modelNameLength;
- CsrUint8 modelNumber[32];
- CsrUint8 modelNumberLength;
- CsrUint8 serialNumber[32];
+ u8 wpsVersion;
+ u8 uuid[16];
+ u8 deviceName[32];
+ u8 deviceNameLength;
+ u8 manufacturer[64];
+ u8 manufacturerLength;
+ u8 modelName[32];
+ u8 modelNameLength;
+ u8 modelNumber[32];
+ u8 modelNumberLength;
+ u8 serialNumber[32];
CsrWifiSmeWpsDeviceType primDeviceType;
- CsrUint8 secondaryDeviceTypeCount;
+ u8 secondaryDeviceTypeCount;
CsrWifiSmeWpsDeviceType *secondaryDeviceType;
CsrWifiSmeWpsConfigTypeMask configMethods;
- CsrUint8 rfBands;
- CsrUint8 osVersion[4];
+ u8 rfBands;
+ u8 osVersion[4];
} CsrWifiSmeWpsConfig;
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
CsrWifiSmeListAction action;
- CsrUint8 setAddressCount;
+ u8 setAddressCount;
CsrWifiMacAddress *setAddresses;
} CsrWifiSmeBlacklistReq;
{
CsrWifiFsmEvent common;
CsrUint16 calibrationDataLength;
- CsrUint8 *calibrationData;
+ u8 *calibrationData;
} CsrWifiSmeCalibrationDataSetReq;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrUint16 mibAttributeLength;
- CsrUint8 *mibAttribute;
+ u8 *mibAttribute;
} CsrWifiSmeMibGetNextReq;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrUint16 mibAttributeLength;
- CsrUint8 *mibAttribute;
+ u8 *mibAttribute;
} CsrWifiSmeMibGetReq;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrUint16 mibAttributeLength;
- CsrUint8 *mibAttribute;
+ u8 *mibAttribute;
} CsrWifiSmeMibSetReq;
/*******************************************************************************
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
CsrWifiSmeListAction action;
- CsrUint8 setAddressesCount;
+ u8 setAddressesCount;
CsrWifiMacAddress *setAddresses;
} CsrWifiSmeMulticastAddressReq;
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
CsrUint16 filterLength;
- CsrUint8 *filter;
+ u8 *filter;
CsrWifiSmePacketFilterMode mode;
CsrWifiIp4Address arpFilterAddress;
} CsrWifiSmePacketFilterSetReq;
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
CsrWifiSmeListAction action;
- CsrUint8 setPmkidsCount;
+ u8 setPmkidsCount;
CsrWifiSmePmkid *setPmkids;
} CsrWifiSmePmkidReq;
typedef struct
{
CsrWifiFsmEvent common;
- CsrUint8 ssidCount;
+ u8 ssidCount;
CsrWifiSsid *ssid;
CsrWifiMacAddress bssid;
CsrBool forceScan;
CsrWifiSmeBssType bssType;
CsrWifiSmeScanType scanType;
CsrUint16 channelListCount;
- CsrUint8 *channelList;
+ u8 *channelList;
CsrUint16 probeIeLength;
- CsrUint8 *probeIe;
+ u8 *probeIe;
} CsrWifiSmeScanFullReq;
/*******************************************************************************
CsrBool strict;
CsrWifiSmeTspecCtrlMask ctrlMask;
CsrUint16 tspecLength;
- CsrUint8 *tspec;
+ u8 *tspec;
CsrUint16 tclasLength;
- CsrUint8 *tclas;
+ u8 *tclas;
} CsrWifiSmeTspecReq;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrUint32 dataLength;
- CsrUint8 *data;
+ u8 *data;
} CsrWifiSmeSetReq;
/*******************************************************************************
CsrUint16 interfaceTag;
CsrResult status;
CsrWifiSmeListAction action;
- CsrUint8 getAddressCount;
+ u8 getAddressCount;
CsrWifiMacAddress *getAddresses;
} CsrWifiSmeBlacklistCfm;
CsrWifiFsmEvent common;
CsrResult status;
CsrUint16 calibrationDataLength;
- CsrUint8 *calibrationData;
+ u8 *calibrationData;
} CsrWifiSmeCalibrationDataGetCfm;
/*******************************************************************************
CsrWifiFsmEvent common;
CsrResult status;
CsrUint16 mibAttributeLength;
- CsrUint8 *mibAttribute;
+ u8 *mibAttribute;
} CsrWifiSmeMibGetCfm;
/*******************************************************************************
CsrWifiFsmEvent common;
CsrResult status;
CsrUint16 mibAttributeLength;
- CsrUint8 *mibAttribute;
+ u8 *mibAttribute;
} CsrWifiSmeMibGetNextCfm;
/*******************************************************************************
CsrUint16 interfaceTag;
CsrResult status;
CsrWifiSmeListAction action;
- CsrUint8 getAddressesCount;
+ u8 getAddressesCount;
CsrWifiMacAddress *getAddresses;
} CsrWifiSmeMulticastAddressCfm;
{
CsrWifiFsmEvent common;
CsrUint16 interfaceTag;
- CsrUint8 pmkidCandidatesCount;
+ u8 pmkidCandidatesCount;
CsrWifiSmePmkidCandidate *pmkidCandidates;
} CsrWifiSmePmkidCandidateListInd;
CsrUint16 interfaceTag;
CsrResult status;
CsrWifiSmeListAction action;
- CsrUint8 getPmkidsCount;
+ u8 getPmkidsCount;
CsrWifiSmePmkid *getPmkids;
} CsrWifiSmePmkidCfm;
CsrUint32 transactionId;
CsrWifiSmeTspecResultCode tspecResultCode;
CsrUint16 tspecLength;
- CsrUint8 *tspec;
+ u8 *tspec;
} CsrWifiSmeTspecInd;
/*******************************************************************************
CsrUint32 transactionId;
CsrWifiSmeTspecResultCode tspecResultCode;
CsrUint16 tspecLength;
- CsrUint8 *tspec;
+ u8 *tspec;
} CsrWifiSmeTspecCfm;
/*******************************************************************************
CsrWifiFsmEvent common;
CsrResult status;
CsrUint16 numInterfaces;
- CsrUint8 capBitmap[2];
+ u8 capBitmap[2];
} CsrWifiSmeInterfaceCapabilityGetCfm;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrUint32 dataLength;
- CsrUint8 *data;
+ u8 *data;
} CsrWifiSmeCoreDumpInd;
/*******************************************************************************
}
-CsrUint8* CsrWifiSmeAdhocConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeAdhocConfigSetReq *primitive = (CsrWifiSmeAdhocConfigSetReq *)msg;
*len = 0;
}
-void* CsrWifiSmeAdhocConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeAdhocConfigSetReq *primitive = (CsrWifiSmeAdhocConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigSetReq));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
- bufferSize += 1; /* CsrUint8 primitive->setAddressCount */
+ bufferSize += 1; /* u8 primitive->setAddressCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->setAddressCount; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->setAddresses[i1].a[6] */
+ bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmeBlacklistReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->setAddressCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->action);
+ CsrUint8Ser(ptr, len, (u8) primitive->setAddressCount);
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->setAddressCount; i1++)
}
-void* CsrWifiSmeBlacklistReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeBlacklistReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *) CsrPmemAlloc(sizeof(CsrWifiSmeBlacklistReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->setAddressCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->setAddressCount, buffer, &offset);
primitive->setAddresses = NULL;
if (primitive->setAddressCount)
{
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
bufferSize += 2; /* CsrUint16 primitive->calibrationDataLength */
- bufferSize += primitive->calibrationDataLength; /* CsrUint8 primitive->calibrationData */
+ bufferSize += primitive->calibrationDataLength; /* u8 primitive->calibrationData */
return bufferSize;
}
-CsrUint8* CsrWifiSmeCalibrationDataSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *)msg;
*len = 0;
}
-void* CsrWifiSmeCalibrationDataSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataSetReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->calibrationDataLength, buffer, &offset);
if (primitive->calibrationDataLength)
{
- primitive->calibrationData = (CsrUint8 *)CsrPmemAlloc(primitive->calibrationDataLength);
+ primitive->calibrationData = (u8 *)CsrPmemAlloc(primitive->calibrationDataLength);
CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((CsrUint16) (primitive->calibrationDataLength)));
}
else
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 1; /* CsrUint8 primitive->ccxConfig.keepAliveTimeMs */
+ bufferSize += 1; /* u8 primitive->ccxConfig.keepAliveTimeMs */
bufferSize += 1; /* CsrBool primitive->ccxConfig.apRoamingEnabled */
- bufferSize += 1; /* CsrUint8 primitive->ccxConfig.measurementsMask */
+ bufferSize += 1; /* u8 primitive->ccxConfig.measurementsMask */
bufferSize += 1; /* CsrBool primitive->ccxConfig.ccxRadioMgtEnabled */
return bufferSize;
}
-CsrUint8* CsrWifiSmeCcxConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCcxConfigSetReq *primitive = (CsrWifiSmeCcxConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.keepAliveTimeMs);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.apRoamingEnabled);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.measurementsMask);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.ccxRadioMgtEnabled);
+ CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.keepAliveTimeMs);
+ CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.apRoamingEnabled);
+ CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.measurementsMask);
+ CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.ccxRadioMgtEnabled);
return(ptr);
}
-void* CsrWifiSmeCcxConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCcxConfigSetReq *primitive = (CsrWifiSmeCcxConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigSetReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.ccxRadioMgtEnabled, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ccxConfig.ccxRadioMgtEnabled, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiSmeCoexConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCoexConfigSetReq *primitive = (CsrWifiSmeCoexConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexEnableSchemeManagement);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexPeriodicWakeHost);
+ 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);
}
-void* CsrWifiSmeCoexConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCoexConfigSetReq *primitive = (CsrWifiSmeCoexConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigSetReq));
CsrSize offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexPeriodicWakeHost, 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);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 57) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 32; /* CsrUint8 primitive->connectionConfig.ssid.ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->connectionConfig.ssid.length */
- bufferSize += 6; /* CsrUint8 primitive->connectionConfig.bssid.a[6] */
+ 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; /* CsrWifiSmeBssType primitive->connectionConfig.bssType */
bufferSize += 1; /* CsrWifiSmeRadioIF primitive->connectionConfig.ifIndex */
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 += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* CsrUint8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
+ bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* u8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
bufferSize += 1; /* CsrWifiSmeWmmQosInfoMask primitive->connectionConfig.wmmQosInfo */
bufferSize += 1; /* CsrBool primitive->connectionConfig.adhocJoinOnly */
- bufferSize += 1; /* CsrUint8 primitive->connectionConfig.adhocChannel */
+ bufferSize += 1; /* u8 primitive->connectionConfig.adhocChannel */
return bufferSize;
}
-CsrUint8* CsrWifiSmeConnectReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectReqSer(u8 *ptr, CsrSize *len, void *msg)
{
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)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ssid.length);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ssid.length);
CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.bssType);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ifIndex);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.privacyMode);
+ 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);
{
CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.wmmQosInfo);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocJoinOnly);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocChannel);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.wmmQosInfo);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocJoinOnly);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocChannel);
return(ptr);
}
-void* CsrWifiSmeConnectReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.bssType, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
+ 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);
if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
{
- primitive->connectionConfig.mlmeAssociateReqInformationElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+ primitive->connectionConfig.mlmeAssociateReqInformationElements = (u8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
}
else
{
primitive->connectionConfig.mlmeAssociateReqInformationElements = NULL;
}
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.wmmQosInfo, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocJoinOnly, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocChannel, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionConfig.wmmQosInfo, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionConfig.adhocJoinOnly, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionConfig.adhocChannel, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiSmeHostConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeHostConfigSetReq *primitive = (CsrWifiSmeHostConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->hostConfig.powerMode);
+ CsrUint8Ser(ptr, len, (u8) primitive->hostConfig.powerMode);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->hostConfig.applicationDataPeriodMs);
return(ptr);
}
-void* CsrWifiSmeHostConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeHostConfigSetReq *primitive = (CsrWifiSmeHostConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigSetReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->hostConfig.powerMode, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->hostConfig.powerMode, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
return primitive;
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 1; /* CsrWifiSmeKeyType primitive->key.keyType */
- bufferSize += 1; /* CsrUint8 primitive->key.keyIndex */
+ bufferSize += 1; /* u8 primitive->key.keyIndex */
bufferSize += 1; /* CsrBool primitive->key.wepTxKey */
{
CsrUint16 i2;
}
}
bufferSize += 1; /* CsrBool primitive->key.authenticator */
- bufferSize += 6; /* CsrUint8 primitive->key.address.a[6] */
- bufferSize += 1; /* CsrUint8 primitive->key.keyLength */
- bufferSize += 32; /* CsrUint8 primitive->key.key[32] */
+ bufferSize += 6; /* u8 primitive->key.address.a[6] */
+ bufferSize += 1; /* u8 primitive->key.keyLength */
+ bufferSize += 32; /* u8 primitive->key.key[32] */
return bufferSize;
}
-CsrUint8* CsrWifiSmeKeyReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeKeyReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeKeyReq *primitive = (CsrWifiSmeKeyReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.keyType);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.keyIndex);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.wepTxKey);
+ 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;
for (i2 = 0; i2 < 8; i2++)
CsrUint16Ser(ptr, len, (CsrUint16) primitive->key.keyRsc[i2]);
}
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.authenticator);
+ CsrUint8Ser(ptr, len, (u8) primitive->key.authenticator);
CsrMemCpySer(ptr, len, (const void *) primitive->key.address.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.keyLength);
+ CsrUint8Ser(ptr, len, (u8) primitive->key.keyLength);
CsrMemCpySer(ptr, len, (const void *) primitive->key.key, ((CsrUint16) (32)));
return(ptr);
}
-void* CsrWifiSmeKeyReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeKeyReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeKeyReq *primitive = (CsrWifiSmeKeyReq *) CsrPmemAlloc(sizeof(CsrWifiSmeKeyReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->key.keyType, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->key.keyIndex, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->key.wepTxKey, 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;
for (i2 = 0; i2 < 8; i2++)
CsrUint16Des((CsrUint16 *) &primitive->key.keyRsc[i2], buffer, &offset);
}
}
- CsrUint8Des((CsrUint8 *) &primitive->key.authenticator, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->key.authenticator, buffer, &offset);
CsrMemCpyDes(primitive->key.address.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->key.keyLength, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->key.keyLength, buffer, &offset);
CsrMemCpyDes(primitive->key.key, buffer, &offset, ((CsrUint16) (32)));
return primitive;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
bufferSize += 1; /* CsrBool primitive->mibConfig.unifiFixMaxTxDataRate */
- bufferSize += 1; /* CsrUint8 primitive->mibConfig.unifiFixTxDataRate */
+ bufferSize += 1; /* u8 primitive->mibConfig.unifiFixTxDataRate */
bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11RtsThreshold */
bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11FragmentationThreshold */
bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11CurrentTxPowerLevel */
}
-CsrUint8* CsrWifiSmeMibConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMibConfigSetReq *primitive = (CsrWifiSmeMibConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixMaxTxDataRate);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixTxDataRate);
+ 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);
}
-void* CsrWifiSmeMibConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMibConfigSetReq *primitive = (CsrWifiSmeMibConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigSetReq));
CsrSize offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixTxDataRate, 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);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
- bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+ bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
return bufferSize;
}
-CsrUint8* CsrWifiSmeMibGetNextReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *)msg;
*len = 0;
}
-void* CsrWifiSmeMibGetNextReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetNextReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
if (primitive->mibAttributeLength)
{
- primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+ primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
}
else
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
- bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+ bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
return bufferSize;
}
-CsrUint8* CsrWifiSmeMibGetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *)msg;
*len = 0;
}
-void* CsrWifiSmeMibGetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
if (primitive->mibAttributeLength)
{
- primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+ primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
}
else
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
- bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+ bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
return bufferSize;
}
-CsrUint8* CsrWifiSmeMibSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *)msg;
*len = 0;
}
-void* CsrWifiSmeMibSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibSetReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
if (primitive->mibAttributeLength)
{
- primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+ primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
}
else
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
- bufferSize += 1; /* CsrUint8 primitive->setAddressesCount */
+ bufferSize += 1; /* u8 primitive->setAddressesCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->setAddresses[i1].a[6] */
+ bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmeMulticastAddressReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->setAddressesCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->action);
+ CsrUint8Ser(ptr, len, (u8) primitive->setAddressesCount);
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
}
-void* CsrWifiSmeMulticastAddressReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMulticastAddressReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->setAddressesCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->setAddressesCount, buffer, &offset);
primitive->setAddresses = NULL;
if (primitive->setAddressesCount)
{
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrUint16 primitive->filterLength */
- bufferSize += primitive->filterLength; /* CsrUint8 primitive->filter */
+ bufferSize += primitive->filterLength; /* u8 primitive->filter */
bufferSize += 1; /* CsrWifiSmePacketFilterMode primitive->mode */
- bufferSize += 4; /* CsrUint8 primitive->arpFilterAddress.a[4] */
+ bufferSize += 4; /* u8 primitive->arpFilterAddress.a[4] */
return bufferSize;
}
-CsrUint8* CsrWifiSmePacketFilterSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *)msg;
*len = 0;
{
CsrMemCpySer(ptr, len, (const void *) primitive->filter, ((CsrUint16) (primitive->filterLength)));
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->mode);
+ CsrUint8Ser(ptr, len, (u8) primitive->mode);
CsrMemCpySer(ptr, len, (const void *) primitive->arpFilterAddress.a, ((CsrUint16) (4)));
return(ptr);
}
-void* CsrWifiSmePacketFilterSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePacketFilterSetReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->filterLength, buffer, &offset);
if (primitive->filterLength)
{
- primitive->filter = (CsrUint8 *)CsrPmemAlloc(primitive->filterLength);
+ primitive->filter = (u8 *)CsrPmemAlloc(primitive->filterLength);
CsrMemCpyDes(primitive->filter, buffer, &offset, ((CsrUint16) (primitive->filterLength)));
}
else
{
primitive->filter = NULL;
}
- CsrUint8Des((CsrUint8 *) &primitive->mode, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
CsrMemCpyDes(primitive->arpFilterAddress.a, buffer, &offset, ((CsrUint16) (4)));
return primitive;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 29) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
- bufferSize += 1; /* CsrUint8 primitive->setPmkidsCount */
+ bufferSize += 1; /* u8 primitive->setPmkidsCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->setPmkids[i1].bssid.a[6] */
- bufferSize += 16; /* CsrUint8 primitive->setPmkids[i1].pmkid[16] */
+ bufferSize += 6; /* u8 primitive->setPmkids[i1].bssid.a[6] */
+ bufferSize += 16; /* u8 primitive->setPmkids[i1].pmkid[16] */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmePmkidReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePmkidReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->setPmkidsCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->action);
+ CsrUint8Ser(ptr, len, (u8) primitive->setPmkidsCount);
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
}
-void* CsrWifiSmePmkidReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePmkidReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->setPmkidsCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->setPmkidsCount, buffer, &offset);
primitive->setPmkids = NULL;
if (primitive->setPmkidsCount)
{
bufferSize += 2; /* CsrUint16 primitive->powerConfig.listenIntervalTu */
bufferSize += 1; /* CsrBool primitive->powerConfig.rxDtims */
bufferSize += 1; /* CsrWifiSmeD3AutoScanMode primitive->powerConfig.d3AutoScanMode */
- bufferSize += 1; /* CsrUint8 primitive->powerConfig.clientTrafficWindow */
+ bufferSize += 1; /* u8 primitive->powerConfig.clientTrafficWindow */
bufferSize += 1; /* CsrBool primitive->powerConfig.opportunisticPowerSave */
bufferSize += 1; /* CsrBool primitive->powerConfig.noticeOfAbsence */
return bufferSize;
}
-CsrUint8* CsrWifiSmePowerConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmePowerConfigSetReq *primitive = (CsrWifiSmePowerConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.powerSaveLevel);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.powerSaveLevel);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->powerConfig.listenIntervalTu);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.rxDtims);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.d3AutoScanMode);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.clientTrafficWindow);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.opportunisticPowerSave);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.noticeOfAbsence);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.rxDtims);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.d3AutoScanMode);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.clientTrafficWindow);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.opportunisticPowerSave);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.noticeOfAbsence);
return(ptr);
}
-void* CsrWifiSmePowerConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmePowerConfigSetReq *primitive = (CsrWifiSmePowerConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigSetReq));
CsrSize offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.opportunisticPowerSave, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.noticeOfAbsence, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.opportunisticPowerSave, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.noticeOfAbsence, buffer, &offset);
return primitive;
}
}
bufferSize += 1; /* CsrBool primitive->roamingConfig.disableSmoothRoaming */
bufferSize += 1; /* CsrBool primitive->roamingConfig.disableRoamScans */
- bufferSize += 1; /* CsrUint8 primitive->roamingConfig.reconnectLimit */
+ bufferSize += 1; /* u8 primitive->roamingConfig.reconnectLimit */
bufferSize += 2; /* CsrUint16 primitive->roamingConfig.reconnectLimitIntervalMs */
{
CsrUint16 i2;
}
-CsrUint8* CsrWifiSmeRoamingConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeRoamingConfigSetReq *primitive = (CsrWifiSmeRoamingConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
}
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableSmoothRoaming);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableRoamScans);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.reconnectLimit);
+ 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);
{
CsrUint16 i2;
}
-void* CsrWifiSmeRoamingConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeRoamingConfigSetReq *primitive = (CsrWifiSmeRoamingConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigSetReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
}
}
- CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.reconnectLimit, 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);
{
CsrUint16 i2;
bufferSize += 1; /* CsrInt8 primitive->scanConfig.lowSnrThreshold */
bufferSize += 1; /* CsrInt8 primitive->scanConfig.deltaSnrThreshold */
bufferSize += 2; /* CsrUint16 primitive->scanConfig.passiveChannelListCount */
- bufferSize += primitive->scanConfig.passiveChannelListCount; /* CsrUint8 primitive->scanConfig.passiveChannelList */
+ bufferSize += primitive->scanConfig.passiveChannelListCount; /* u8 primitive->scanConfig.passiveChannelList */
return bufferSize;
}
-CsrUint8* CsrWifiSmeScanConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
}
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.disableAutonomousScans);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.disableAutonomousScans);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.maxResults);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highRssiThreshold);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowRssiThreshold);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaRssiThreshold);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highSnrThreshold);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowSnrThreshold);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaSnrThreshold);
+ 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);
if (primitive->scanConfig.passiveChannelListCount)
{
}
-void* CsrWifiSmeScanConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigSetReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
}
}
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->scanConfig.maxResults, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaSnrThreshold, 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);
if (primitive->scanConfig.passiveChannelListCount)
{
- primitive->scanConfig.passiveChannelList = (CsrUint8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
+ primitive->scanConfig.passiveChannelList = (u8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
}
else
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 52) */
- bufferSize += 1; /* CsrUint8 primitive->ssidCount */
+ bufferSize += 1; /* u8 primitive->ssidCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->ssidCount; i1++)
{
- bufferSize += 32; /* CsrUint8 primitive->ssid[i1].ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->ssid[i1].length */
+ bufferSize += 32; /* u8 primitive->ssid[i1].ssid[32] */
+ bufferSize += 1; /* u8 primitive->ssid[i1].length */
}
}
- bufferSize += 6; /* CsrUint8 primitive->bssid.a[6] */
+ bufferSize += 6; /* u8 primitive->bssid.a[6] */
bufferSize += 1; /* CsrBool primitive->forceScan */
bufferSize += 1; /* CsrWifiSmeBssType primitive->bssType */
bufferSize += 1; /* CsrWifiSmeScanType primitive->scanType */
bufferSize += 2; /* CsrUint16 primitive->channelListCount */
- bufferSize += primitive->channelListCount; /* CsrUint8 primitive->channelList */
+ bufferSize += primitive->channelListCount; /* u8 primitive->channelList */
bufferSize += 2; /* CsrUint16 primitive->probeIeLength */
- bufferSize += primitive->probeIeLength; /* CsrUint8 primitive->probeIe */
+ bufferSize += primitive->probeIeLength; /* u8 primitive->probeIe */
return bufferSize;
}
-CsrUint8* CsrWifiSmeScanFullReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanFullReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssidCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->ssidCount);
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->ssidCount; i1++)
{
CsrMemCpySer(ptr, len, (const void *) primitive->ssid[i1].ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid[i1].length);
+ CsrUint8Ser(ptr, len, (u8) primitive->ssid[i1].length);
}
}
CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->forceScan);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->bssType);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanType);
+ CsrUint8Ser(ptr, len, (u8) primitive->forceScan);
+ CsrUint8Ser(ptr, len, (u8) primitive->bssType);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanType);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->channelListCount);
if (primitive->channelListCount)
{
}
-void* CsrWifiSmeScanFullReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeScanFullReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanFullReq));
CsrSize offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ssidCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ssidCount, buffer, &offset);
primitive->ssid = NULL;
if (primitive->ssidCount)
{
for (i1 = 0; i1 < primitive->ssidCount; i1++)
{
CsrMemCpyDes(primitive->ssid[i1].ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->ssid[i1].length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ssid[i1].length, buffer, &offset);
}
}
CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->forceScan, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->bssType, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->forceScan, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->bssType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanType, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->channelListCount, buffer, &offset);
if (primitive->channelListCount)
{
- primitive->channelList = (CsrUint8 *)CsrPmemAlloc(primitive->channelListCount);
+ primitive->channelList = (u8 *)CsrPmemAlloc(primitive->channelListCount);
CsrMemCpyDes(primitive->channelList, buffer, &offset, ((CsrUint16) (primitive->channelListCount)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->probeIeLength, buffer, &offset);
if (primitive->probeIeLength)
{
- primitive->probeIe = (CsrUint8 *)CsrPmemAlloc(primitive->probeIeLength);
+ primitive->probeIe = (u8 *)CsrPmemAlloc(primitive->probeIeLength);
CsrMemCpyDes(primitive->probeIe, buffer, &offset, ((CsrUint16) (primitive->probeIeLength)));
}
else
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
- bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
+ bufferSize += 1; /* u8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
+ bufferSize += 1; /* u8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
bufferSize += 1; /* CsrWifiSmeWmmModeMask primitive->smeConfig.wmmModeMask */
bufferSize += 1; /* CsrWifiSmeRadioIF primitive->smeConfig.ifIndex */
bufferSize += 1; /* CsrBool primitive->smeConfig.allowUnicastUseGroupCipher */
}
-CsrUint8* CsrWifiSmeSmeStaConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeSmeStaConfigSetReq *primitive = (CsrWifiSmeSmeStaConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.wmmModeMask);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.ifIndex);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.allowUnicastUseGroupCipher);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.enableOpportunisticKeyCaching);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.wmmModeMask);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.ifIndex);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.allowUnicastUseGroupCipher);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.enableOpportunisticKeyCaching);
return(ptr);
}
-void* CsrWifiSmeSmeStaConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeSmeStaConfigSetReq *primitive = (CsrWifiSmeSmeStaConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigSetReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.ifIndex, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.allowUnicastUseGroupCipher, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.enableOpportunisticKeyCaching, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.ifIndex, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.allowUnicastUseGroupCipher, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.enableOpportunisticKeyCaching, buffer, &offset);
return primitive;
}
bufferSize += 1; /* CsrBool primitive->strict */
bufferSize += 1; /* CsrWifiSmeTspecCtrlMask primitive->ctrlMask */
bufferSize += 2; /* CsrUint16 primitive->tspecLength */
- bufferSize += primitive->tspecLength; /* CsrUint8 primitive->tspec */
+ bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
bufferSize += 2; /* CsrUint16 primitive->tclasLength */
- bufferSize += primitive->tclasLength; /* CsrUint8 primitive->tclas */
+ bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
return bufferSize;
}
-CsrUint8* CsrWifiSmeTspecReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeTspecReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (u8) primitive->action);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->strict);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ctrlMask);
+ CsrUint8Ser(ptr, len, (u8) primitive->strict);
+ CsrUint8Ser(ptr, len, (u8) primitive->ctrlMask);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
if (primitive->tspecLength)
{
}
-void* CsrWifiSmeTspecReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeTspecReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecReq));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->strict, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ctrlMask, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->strict, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ctrlMask, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
if (primitive->tspecLength)
{
- primitive->tspec = (CsrUint8 *)CsrPmemAlloc(primitive->tspecLength);
+ primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
if (primitive->tclasLength)
{
- primitive->tclas = (CsrUint8 *)CsrPmemAlloc(primitive->tclasLength);
+ primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
}
else
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
- bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ bufferSize += 6; /* u8 primitive->address.a[6] */
bufferSize += 2; /* CsrUint16 primitive->mibFilesCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
{
bufferSize += 2; /* CsrUint16 primitive->mibFiles[i1].length */
- bufferSize += primitive->mibFiles[i1].length; /* CsrUint8 primitive->mibFiles[i1].data */
+ bufferSize += primitive->mibFiles[i1].length; /* u8 primitive->mibFiles[i1].data */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmeWifiFlightmodeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *)msg;
*len = 0;
}
-void* CsrWifiSmeWifiFlightmodeReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiFlightmodeReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->mibFiles[i1].length, buffer, &offset);
if (primitive->mibFiles[i1].length)
{
- primitive->mibFiles[i1].data = (CsrUint8 *)CsrPmemAlloc(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)));
}
else
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
- bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ bufferSize += 6; /* u8 primitive->address.a[6] */
bufferSize += 2; /* CsrUint16 primitive->mibFilesCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
{
bufferSize += 2; /* CsrUint16 primitive->mibFiles[i1].length */
- bufferSize += primitive->mibFiles[i1].length; /* CsrUint8 primitive->mibFiles[i1].data */
+ bufferSize += primitive->mibFiles[i1].length; /* u8 primitive->mibFiles[i1].data */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmeWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *)msg;
*len = 0;
}
-void* CsrWifiSmeWifiOnReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeWifiOnReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnReq));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->mibFiles[i1].length, buffer, &offset);
if (primitive->mibFiles[i1].length)
{
- primitive->mibFiles[i1].data = (CsrUint8 *)CsrPmemAlloc(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)));
}
else
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 37) */
- bufferSize += 1; /* CsrUint8 primitive->cloakedSsids.cloakedSsidsCount */
+ bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsidsCount */
{
CsrUint16 i2;
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
- bufferSize += 32; /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].length */
+ bufferSize += 32; /* u8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
+ bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsids[i2].length */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmeCloakedSsidsSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsidsCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsidsCount);
{
CsrUint16 i2;
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsids[i2].length);
+ CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsids[i2].length);
}
}
return(ptr);
}
-void* CsrWifiSmeCloakedSsidsSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsSetReq));
CsrSize offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
primitive->cloakedSsids.cloakedSsids = NULL;
if (primitive->cloakedSsids.cloakedSsidsCount)
{
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
}
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 1; /* CsrWifiSme80211dTrustLevel primitive->deviceConfig.trustLevel */
- bufferSize += 2; /* CsrUint8 primitive->deviceConfig.countryCode[2] */
+ bufferSize += 2; /* u8 primitive->deviceConfig.countryCode[2] */
bufferSize += 1; /* CsrWifiSmeFirmwareDriverInterface primitive->deviceConfig.firmwareDriverInterface */
bufferSize += 1; /* CsrBool primitive->deviceConfig.enableStrictDraftN */
return bufferSize;
}
-CsrUint8* CsrWifiSmeSmeCommonConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeSmeCommonConfigSetReq *primitive = (CsrWifiSmeSmeCommonConfigSetReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.trustLevel);
+ CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.trustLevel);
CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((CsrUint16) (2)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.firmwareDriverInterface);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.enableStrictDraftN);
+ CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.firmwareDriverInterface);
+ CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.enableStrictDraftN);
return(ptr);
}
-void* CsrWifiSmeSmeCommonConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeSmeCommonConfigSetReq *primitive = (CsrWifiSmeSmeCommonConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigSetReq));
CsrSize offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((CsrUint16) (2)));
- CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
return primitive;
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 240) */
- bufferSize += 1; /* CsrUint8 primitive->wpsConfig.wpsVersion */
- bufferSize += 16; /* CsrUint8 primitive->wpsConfig.uuid[16] */
- bufferSize += 32; /* CsrUint8 primitive->wpsConfig.deviceName[32] */
- bufferSize += 1; /* CsrUint8 primitive->wpsConfig.deviceNameLength */
- bufferSize += 64; /* CsrUint8 primitive->wpsConfig.manufacturer[64] */
- bufferSize += 1; /* CsrUint8 primitive->wpsConfig.manufacturerLength */
- bufferSize += 32; /* CsrUint8 primitive->wpsConfig.modelName[32] */
- bufferSize += 1; /* CsrUint8 primitive->wpsConfig.modelNameLength */
- bufferSize += 32; /* CsrUint8 primitive->wpsConfig.modelNumber[32] */
- bufferSize += 1; /* CsrUint8 primitive->wpsConfig.modelNumberLength */
- bufferSize += 32; /* CsrUint8 primitive->wpsConfig.serialNumber[32] */
- bufferSize += 8; /* CsrUint8 primitive->wpsConfig.primDeviceType.deviceDetails[8] */
- bufferSize += 1; /* CsrUint8 primitive->wpsConfig.secondaryDeviceTypeCount */
+ bufferSize += 1; /* u8 primitive->wpsConfig.wpsVersion */
+ bufferSize += 16; /* u8 primitive->wpsConfig.uuid[16] */
+ bufferSize += 32; /* u8 primitive->wpsConfig.deviceName[32] */
+ bufferSize += 1; /* u8 primitive->wpsConfig.deviceNameLength */
+ bufferSize += 64; /* u8 primitive->wpsConfig.manufacturer[64] */
+ bufferSize += 1; /* u8 primitive->wpsConfig.manufacturerLength */
+ bufferSize += 32; /* u8 primitive->wpsConfig.modelName[32] */
+ bufferSize += 1; /* u8 primitive->wpsConfig.modelNameLength */
+ bufferSize += 32; /* u8 primitive->wpsConfig.modelNumber[32] */
+ bufferSize += 1; /* u8 primitive->wpsConfig.modelNumberLength */
+ bufferSize += 32; /* u8 primitive->wpsConfig.serialNumber[32] */
+ bufferSize += 8; /* u8 primitive->wpsConfig.primDeviceType.deviceDetails[8] */
+ bufferSize += 1; /* u8 primitive->wpsConfig.secondaryDeviceTypeCount */
{
CsrUint16 i2;
for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
{
- bufferSize += 8; /* CsrUint8 primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails[8] */
+ bufferSize += 8; /* u8 primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails[8] */
}
}
bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->wpsConfig.configMethods */
- bufferSize += 1; /* CsrUint8 primitive->wpsConfig.rfBands */
- bufferSize += 4; /* CsrUint8 primitive->wpsConfig.osVersion[4] */
+ bufferSize += 1; /* u8 primitive->wpsConfig.rfBands */
+ bufferSize += 4; /* u8 primitive->wpsConfig.osVersion[4] */
return bufferSize;
}
-CsrUint8* CsrWifiSmeWpsConfigurationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.wpsVersion);
+ 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)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.deviceNameLength);
+ CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.deviceNameLength);
CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.manufacturer, ((CsrUint16) (64)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.manufacturerLength);
+ CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.manufacturerLength);
CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelName, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.modelNameLength);
+ CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.modelNameLength);
CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelNumber, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.modelNumberLength);
+ 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)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.secondaryDeviceTypeCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.secondaryDeviceTypeCount);
{
CsrUint16 i2;
for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
}
}
CsrUint16Ser(ptr, len, (CsrUint16) primitive->wpsConfig.configMethods);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.rfBands);
+ CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.rfBands);
CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.osVersion, ((CsrUint16) (4)));
return(ptr);
}
-void* CsrWifiSmeWpsConfigurationReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWpsConfigurationReq));
CsrSize offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.wpsVersion, 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)));
- CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.deviceNameLength, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->wpsConfig.deviceNameLength, buffer, &offset);
CsrMemCpyDes(primitive->wpsConfig.manufacturer, buffer, &offset, ((CsrUint16) (64)));
- CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.manufacturerLength, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->wpsConfig.manufacturerLength, buffer, &offset);
CsrMemCpyDes(primitive->wpsConfig.modelName, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.modelNameLength, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->wpsConfig.modelNameLength, buffer, &offset);
CsrMemCpyDes(primitive->wpsConfig.modelNumber, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.modelNumberLength, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->wpsConfig.modelNumberLength, buffer, &offset);
CsrMemCpyDes(primitive->wpsConfig.serialNumber, buffer, &offset, ((CsrUint16) (32)));
CsrMemCpyDes(primitive->wpsConfig.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
- CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.secondaryDeviceTypeCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->wpsConfig.secondaryDeviceTypeCount, buffer, &offset);
primitive->wpsConfig.secondaryDeviceType = NULL;
if (primitive->wpsConfig.secondaryDeviceTypeCount)
{
}
}
CsrUint16Des((CsrUint16 *) &primitive->wpsConfig.configMethods, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.rfBands, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->wpsConfig.rfBands, buffer, &offset);
CsrMemCpyDes(primitive->wpsConfig.osVersion, buffer, &offset, ((CsrUint16) (4)));
return primitive;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 4; /* CsrUint32 primitive->dataLength */
- bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
-CsrUint8* CsrWifiSmeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSetReqSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *)msg;
*len = 0;
}
-void* CsrWifiSmeSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSetReqDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSetReq));
CsrSize offset;
CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
- primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
}
else
}
-CsrUint8* CsrWifiSmeAdhocConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeAdhocConfigGetCfm *primitive = (CsrWifiSmeAdhocConfigGetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeAdhocConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeAdhocConfigGetCfm *primitive = (CsrWifiSmeAdhocConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigGetCfm));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 98) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 32; /* CsrUint8 primitive->connectionInfo.ssid.ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->connectionInfo.ssid.length */
- bufferSize += 6; /* CsrUint8 primitive->connectionInfo.bssid.a[6] */
+ 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; /* CsrUint8 primitive->connectionInfo.channelNumber */
+ bufferSize += 1; /* u8 primitive->connectionInfo.channelNumber */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.channelFrequency */
bufferSize += 2; /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
bufferSize += 1; /* CsrBool primitive->connectionInfo.reassociation */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
- bufferSize += primitive->connectionInfo.beaconFrameLength; /* CsrUint8 primitive->connectionInfo.beaconFrame */
+ bufferSize += primitive->connectionInfo.beaconFrameLength; /* u8 primitive->connectionInfo.beaconFrame */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
- bufferSize += primitive->connectionInfo.associationReqFrameLength; /* CsrUint8 primitive->connectionInfo.associationReqFrame */
+ bufferSize += primitive->connectionInfo.associationReqFrameLength; /* u8 primitive->connectionInfo.associationReqFrame */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
- bufferSize += primitive->connectionInfo.associationRspFrameLength; /* CsrUint8 primitive->connectionInfo.associationRspFrame */
+ bufferSize += primitive->connectionInfo.associationRspFrameLength; /* u8 primitive->connectionInfo.associationRspFrame */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
- bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocScanInfoElements */
+ bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
- bufferSize += 6; /* CsrUint8 primitive->connectionInfo.assocReqApAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
- bufferSize += primitive->connectionInfo.assocReqInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocReqInfoElements */
+ 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 += primitive->connectionInfo.assocRspInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocRspInfoElements */
+ bufferSize += primitive->connectionInfo.assocRspInfoElementsLength; /* u8 primitive->connectionInfo.assocRspInfoElements */
bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->deauthReason */
return bufferSize;
}
-CsrUint8* CsrWifiSmeAssociationCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ssid.length);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.networkType80211);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.channelNumber);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ifIndex);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.reassociation);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
if (primitive->connectionInfo.beaconFrameLength)
{
}
-void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAssociationCompleteInd));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
+ 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);
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
if (primitive->connectionInfo.beaconFrameLength)
{
- primitive->connectionInfo.beaconFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
+ primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationReqFrameLength)
{
- primitive->connectionInfo.associationReqFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
+ primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationRspFrameLength)
{
- primitive->connectionInfo.associationRspFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
+ primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocScanInfoElementsLength)
{
- primitive->connectionInfo.assocScanInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
+ primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocReqInfoElementsLength)
{
- primitive->connectionInfo.assocReqInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
+ primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocRspInfoElementsLength)
{
- primitive->connectionInfo.assocRspInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
+ primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
}
else
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 44) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
- bufferSize += 32; /* CsrUint8 primitive->ssid.ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->ssid.length */
+ bufferSize += 6; /* u8 primitive->address.a[6] */
+ bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
+ bufferSize += 1; /* u8 primitive->ssid.length */
return bufferSize;
}
-CsrUint8* CsrWifiSmeAssociationStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeAssociationStartInd *primitive = (CsrWifiSmeAssociationStartInd *)msg;
*len = 0;
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)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid.length);
+ CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
return(ptr);
}
-void* CsrWifiSmeAssociationStartIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeAssociationStartInd *primitive = (CsrWifiSmeAssociationStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAssociationStartInd));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->ssid.length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
return primitive;
}
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
- bufferSize += 1; /* CsrUint8 primitive->getAddressCount */
+ bufferSize += 1; /* u8 primitive->getAddressCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->getAddressCount; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->getAddresses[i1].a[6] */
+ bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmeBlacklistCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->getAddressCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->action);
+ CsrUint8Ser(ptr, len, (u8) primitive->getAddressCount);
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->getAddressCount; i1++)
}
-void* CsrWifiSmeBlacklistCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeBlacklistCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->getAddressCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->getAddressCount, buffer, &offset);
primitive->getAddresses = NULL;
if (primitive->getAddressCount)
{
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 2; /* CsrUint16 primitive->calibrationDataLength */
- bufferSize += primitive->calibrationDataLength; /* CsrUint8 primitive->calibrationData */
+ bufferSize += primitive->calibrationDataLength; /* u8 primitive->calibrationData */
return bufferSize;
}
-CsrUint8* CsrWifiSmeCalibrationDataGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeCalibrationDataGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataGetCfm));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->calibrationDataLength, buffer, &offset);
if (primitive->calibrationDataLength)
{
- primitive->calibrationData = (CsrUint8 *)CsrPmemAlloc(primitive->calibrationDataLength);
+ primitive->calibrationData = (u8 *)CsrPmemAlloc(primitive->calibrationDataLength);
CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((CsrUint16) (primitive->calibrationDataLength)));
}
else
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 1; /* CsrUint8 primitive->ccxConfig.keepAliveTimeMs */
+ bufferSize += 1; /* u8 primitive->ccxConfig.keepAliveTimeMs */
bufferSize += 1; /* CsrBool primitive->ccxConfig.apRoamingEnabled */
- bufferSize += 1; /* CsrUint8 primitive->ccxConfig.measurementsMask */
+ bufferSize += 1; /* u8 primitive->ccxConfig.measurementsMask */
bufferSize += 1; /* CsrBool primitive->ccxConfig.ccxRadioMgtEnabled */
return bufferSize;
}
-CsrUint8* CsrWifiSmeCcxConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCcxConfigGetCfm *primitive = (CsrWifiSmeCcxConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.keepAliveTimeMs);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.apRoamingEnabled);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.measurementsMask);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.ccxRadioMgtEnabled);
+ CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.keepAliveTimeMs);
+ CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.apRoamingEnabled);
+ CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.measurementsMask);
+ CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.ccxRadioMgtEnabled);
return(ptr);
}
-void* CsrWifiSmeCcxConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCcxConfigGetCfm *primitive = (CsrWifiSmeCcxConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.ccxRadioMgtEnabled, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->ccxConfig.ccxRadioMgtEnabled, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiSmeCcxConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCcxConfigSetCfm *primitive = (CsrWifiSmeCcxConfigSetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeCcxConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCcxConfigSetCfm *primitive = (CsrWifiSmeCcxConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigSetCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiSmeCoexConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCoexConfigGetCfm *primitive = (CsrWifiSmeCoexConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexEnableSchemeManagement);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexPeriodicWakeHost);
+ 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);
}
-void* CsrWifiSmeCoexConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCoexConfigGetCfm *primitive = (CsrWifiSmeCoexConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexPeriodicWakeHost, 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);
}
-CsrUint8* CsrWifiSmeCoexInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCoexInfoGetCfm *primitive = (CsrWifiSmeCoexInfoGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.hasTrafficData);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.currentTrafficType);
+ CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.hasTrafficData);
+ CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentTrafficType);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentPeriodMs);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.currentPowerSave);
+ CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentPowerSave);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentCoexPeriodMs);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentCoexLatencyMs);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.hasBtDevice);
+ CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.hasBtDevice);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->coexInfo.currentBlackoutDurationUs);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->coexInfo.currentBlackoutPeriodUs);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.currentCoexScheme);
+ CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentCoexScheme);
return(ptr);
}
-void* CsrWifiSmeCoexInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCoexInfoGetCfm *primitive = (CsrWifiSmeCoexInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexInfoGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->coexInfo.hasTrafficData, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->coexInfo.currentTrafficType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->coexInfo.hasTrafficData, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->coexInfo.currentTrafficType, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentPeriodMs, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->coexInfo.currentPowerSave, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->coexInfo.currentPowerSave, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentCoexPeriodMs, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentCoexLatencyMs, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->coexInfo.hasBtDevice, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->coexInfo.hasBtDevice, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->coexInfo.currentBlackoutDurationUs, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->coexInfo.currentBlackoutPeriodUs, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->coexInfo.currentCoexScheme, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->coexInfo.currentCoexScheme, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiSmeConnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeConnectCfm *primitive = (CsrWifiSmeConnectCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeConnectCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeConnectCfm *primitive = (CsrWifiSmeConnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectCfm));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 59) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 32; /* CsrUint8 primitive->connectionConfig.ssid.ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->connectionConfig.ssid.length */
- bufferSize += 6; /* CsrUint8 primitive->connectionConfig.bssid.a[6] */
+ 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; /* CsrWifiSmeBssType primitive->connectionConfig.bssType */
bufferSize += 1; /* CsrWifiSmeRadioIF primitive->connectionConfig.ifIndex */
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 += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* CsrUint8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
+ bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* u8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
bufferSize += 1; /* CsrWifiSmeWmmQosInfoMask primitive->connectionConfig.wmmQosInfo */
bufferSize += 1; /* CsrBool primitive->connectionConfig.adhocJoinOnly */
- bufferSize += 1; /* CsrUint8 primitive->connectionConfig.adhocChannel */
+ bufferSize += 1; /* u8 primitive->connectionConfig.adhocChannel */
return bufferSize;
}
-CsrUint8* CsrWifiSmeConnectionConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ssid.length);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ssid.length);
CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.bssType);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ifIndex);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.privacyMode);
+ 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);
{
CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.wmmQosInfo);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocJoinOnly);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocChannel);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.wmmQosInfo);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocJoinOnly);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocChannel);
return(ptr);
}
-void* CsrWifiSmeConnectionConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionConfigGetCfm));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.bssType, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
+ 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);
if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
{
- primitive->connectionConfig.mlmeAssociateReqInformationElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+ primitive->connectionConfig.mlmeAssociateReqInformationElements = (u8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
}
else
{
primitive->connectionConfig.mlmeAssociateReqInformationElements = NULL;
}
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.wmmQosInfo, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocJoinOnly, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocChannel, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionConfig.wmmQosInfo, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionConfig.adhocJoinOnly, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionConfig.adhocChannel, buffer, &offset);
return primitive;
}
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 96) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 32; /* CsrUint8 primitive->connectionInfo.ssid.ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->connectionInfo.ssid.length */
- bufferSize += 6; /* CsrUint8 primitive->connectionInfo.bssid.a[6] */
+ 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; /* CsrUint8 primitive->connectionInfo.channelNumber */
+ bufferSize += 1; /* u8 primitive->connectionInfo.channelNumber */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.channelFrequency */
bufferSize += 2; /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
bufferSize += 1; /* CsrBool primitive->connectionInfo.reassociation */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
- bufferSize += primitive->connectionInfo.beaconFrameLength; /* CsrUint8 primitive->connectionInfo.beaconFrame */
+ bufferSize += primitive->connectionInfo.beaconFrameLength; /* u8 primitive->connectionInfo.beaconFrame */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
- bufferSize += primitive->connectionInfo.associationReqFrameLength; /* CsrUint8 primitive->connectionInfo.associationReqFrame */
+ bufferSize += primitive->connectionInfo.associationReqFrameLength; /* u8 primitive->connectionInfo.associationReqFrame */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
- bufferSize += primitive->connectionInfo.associationRspFrameLength; /* CsrUint8 primitive->connectionInfo.associationRspFrame */
+ bufferSize += primitive->connectionInfo.associationRspFrameLength; /* u8 primitive->connectionInfo.associationRspFrame */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
- bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocScanInfoElements */
+ bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
- bufferSize += 6; /* CsrUint8 primitive->connectionInfo.assocReqApAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
- bufferSize += primitive->connectionInfo.assocReqInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocReqInfoElements */
+ 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 += primitive->connectionInfo.assocRspInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocRspInfoElements */
+ bufferSize += primitive->connectionInfo.assocRspInfoElementsLength; /* u8 primitive->connectionInfo.assocRspInfoElements */
return bufferSize;
}
-CsrUint8* CsrWifiSmeConnectionInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ssid.length);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.networkType80211);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.channelNumber);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ifIndex);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.reassociation);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
if (primitive->connectionInfo.beaconFrameLength)
{
}
-void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionInfoGetCfm));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
+ 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);
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
if (primitive->connectionInfo.beaconFrameLength)
{
- primitive->connectionInfo.beaconFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
+ primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationReqFrameLength)
{
- primitive->connectionInfo.associationReqFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
+ primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationRspFrameLength)
{
- primitive->connectionInfo.associationRspFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
+ primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocScanInfoElementsLength)
{
- primitive->connectionInfo.assocScanInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
+ primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocReqInfoElementsLength)
{
- primitive->connectionInfo.assocReqInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
+ primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocRspInfoElementsLength)
{
- primitive->connectionInfo.assocRspInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
+ primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
}
else
}
-CsrUint8* CsrWifiSmeConnectionQualityIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeConnectionQualityInd *primitive = (CsrWifiSmeConnectionQualityInd *)msg;
*len = 0;
}
-void* CsrWifiSmeConnectionQualityIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeConnectionQualityInd *primitive = (CsrWifiSmeConnectionQualityInd *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionQualityInd));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 101) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 1; /* CsrUint8 primitive->connectionStats.unifiTxDataRate */
- bufferSize += 1; /* CsrUint8 primitive->connectionStats.unifiRxDataRate */
+ bufferSize += 1; /* u8 primitive->connectionStats.unifiTxDataRate */
+ bufferSize += 1; /* u8 primitive->connectionStats.unifiRxDataRate */
bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RetryCount */
bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11MultipleRetryCount */
bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11AckFailureCount */
}
-CsrUint8* CsrWifiSmeConnectionStatsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeConnectionStatsGetCfm *primitive = (CsrWifiSmeConnectionStatsGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionStats.unifiTxDataRate);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionStats.unifiRxDataRate);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionStats.unifiTxDataRate);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionStats.unifiRxDataRate);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RetryCount);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11MultipleRetryCount);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11AckFailureCount);
}
-void* CsrWifiSmeConnectionStatsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeConnectionStatsGetCfm *primitive = (CsrWifiSmeConnectionStatsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionStatsGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionStats.unifiTxDataRate, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionStats.unifiRxDataRate, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionStats.unifiTxDataRate, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionStats.unifiRxDataRate, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RetryCount, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11MultipleRetryCount, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11AckFailureCount, buffer, &offset);
}
-CsrUint8* CsrWifiSmeDisconnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeDisconnectCfm *primitive = (CsrWifiSmeDisconnectCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeDisconnectCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeDisconnectCfm *primitive = (CsrWifiSmeDisconnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeDisconnectCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiSmeHostConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeHostConfigGetCfm *primitive = (CsrWifiSmeHostConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->hostConfig.powerMode);
+ CsrUint8Ser(ptr, len, (u8) primitive->hostConfig.powerMode);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->hostConfig.applicationDataPeriodMs);
return(ptr);
}
-void* CsrWifiSmeHostConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeHostConfigGetCfm *primitive = (CsrWifiSmeHostConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->hostConfig.powerMode, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->hostConfig.powerMode, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
return primitive;
}
-CsrUint8* CsrWifiSmeHostConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeHostConfigSetCfm *primitive = (CsrWifiSmeHostConfigSetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeHostConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeHostConfigSetCfm *primitive = (CsrWifiSmeHostConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigSetCfm));
CsrSize offset;
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
- bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ bufferSize += 6; /* u8 primitive->address.a[6] */
bufferSize += 1; /* CsrBool primitive->isconnected */
return bufferSize;
}
-CsrUint8* CsrWifiSmeIbssStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeIbssStationInd *primitive = (CsrWifiSmeIbssStationInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->isconnected);
+ CsrUint8Ser(ptr, len, (u8) primitive->isconnected);
return(ptr);
}
-void* CsrWifiSmeIbssStationIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeIbssStationIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeIbssStationInd *primitive = (CsrWifiSmeIbssStationInd *) CsrPmemAlloc(sizeof(CsrWifiSmeIbssStationInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->isconnected, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->isconnected, buffer, &offset);
return primitive;
}
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
bufferSize += 1; /* CsrWifiSmeKeyType primitive->keyType */
- bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
return bufferSize;
}
-CsrUint8* CsrWifiSmeKeyCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeKeyCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeKeyCfm *primitive = (CsrWifiSmeKeyCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->keyType);
+ CsrUint8Ser(ptr, len, (u8) primitive->action);
+ CsrUint8Ser(ptr, len, (u8) primitive->keyType);
CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
return(ptr);
}
-void* CsrWifiSmeKeyCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeKeyCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeKeyCfm *primitive = (CsrWifiSmeKeyCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeKeyCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->keyType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->keyType, buffer, &offset);
CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
return primitive;
}
-CsrUint8* CsrWifiSmeLinkQualityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeLinkQualityGetCfm *primitive = (CsrWifiSmeLinkQualityGetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeLinkQualityGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeLinkQualityGetCfm *primitive = (CsrWifiSmeLinkQualityGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeLinkQualityGetCfm));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 99) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 1; /* CsrWifiSmeMediaStatus primitive->mediaStatus */
- bufferSize += 32; /* CsrUint8 primitive->connectionInfo.ssid.ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->connectionInfo.ssid.length */
- bufferSize += 6; /* CsrUint8 primitive->connectionInfo.bssid.a[6] */
+ 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; /* CsrUint8 primitive->connectionInfo.channelNumber */
+ bufferSize += 1; /* u8 primitive->connectionInfo.channelNumber */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.channelFrequency */
bufferSize += 2; /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
bufferSize += 1; /* CsrBool primitive->connectionInfo.reassociation */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
- bufferSize += primitive->connectionInfo.beaconFrameLength; /* CsrUint8 primitive->connectionInfo.beaconFrame */
+ bufferSize += primitive->connectionInfo.beaconFrameLength; /* u8 primitive->connectionInfo.beaconFrame */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
- bufferSize += primitive->connectionInfo.associationReqFrameLength; /* CsrUint8 primitive->connectionInfo.associationReqFrame */
+ bufferSize += primitive->connectionInfo.associationReqFrameLength; /* u8 primitive->connectionInfo.associationReqFrame */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
- bufferSize += primitive->connectionInfo.associationRspFrameLength; /* CsrUint8 primitive->connectionInfo.associationRspFrame */
+ bufferSize += primitive->connectionInfo.associationRspFrameLength; /* u8 primitive->connectionInfo.associationRspFrame */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
- bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocScanInfoElements */
+ bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
- bufferSize += 6; /* CsrUint8 primitive->connectionInfo.assocReqApAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
- bufferSize += primitive->connectionInfo.assocReqInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocReqInfoElements */
+ 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 += primitive->connectionInfo.assocRspInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocRspInfoElements */
+ bufferSize += primitive->connectionInfo.assocRspInfoElementsLength; /* u8 primitive->connectionInfo.assocRspInfoElements */
bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->disassocReason */
bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->deauthReason */
return bufferSize;
}
-CsrUint8* CsrWifiSmeMediaStatusIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->mediaStatus);
+ CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ssid.length);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.networkType80211);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.channelNumber);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ifIndex);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.reassociation);
+ CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
if (primitive->connectionInfo.beaconFrameLength)
{
}
-void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *) CsrPmemAlloc(sizeof(CsrWifiSmeMediaStatusInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->mediaStatus, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
+ 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);
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
if (primitive->connectionInfo.beaconFrameLength)
{
- primitive->connectionInfo.beaconFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
+ primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationReqFrameLength)
{
- primitive->connectionInfo.associationReqFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
+ primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
if (primitive->connectionInfo.associationRspFrameLength)
{
- primitive->connectionInfo.associationRspFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
+ primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocScanInfoElementsLength)
{
- primitive->connectionInfo.assocScanInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
+ primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocReqInfoElementsLength)
{
- primitive->connectionInfo.assocReqInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
+ primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
}
else
CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
if (primitive->connectionInfo.assocRspInfoElementsLength)
{
- primitive->connectionInfo.assocRspInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
+ primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
}
else
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrBool primitive->mibConfig.unifiFixMaxTxDataRate */
- bufferSize += 1; /* CsrUint8 primitive->mibConfig.unifiFixTxDataRate */
+ bufferSize += 1; /* u8 primitive->mibConfig.unifiFixTxDataRate */
bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11RtsThreshold */
bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11FragmentationThreshold */
bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11CurrentTxPowerLevel */
}
-CsrUint8* CsrWifiSmeMibConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMibConfigGetCfm *primitive = (CsrWifiSmeMibConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixMaxTxDataRate);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixTxDataRate);
+ 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);
}
-void* CsrWifiSmeMibConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMibConfigGetCfm *primitive = (CsrWifiSmeMibConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixTxDataRate, 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);
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
- bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+ bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
return bufferSize;
}
-CsrUint8* CsrWifiSmeMibGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeMibGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetCfm));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
if (primitive->mibAttributeLength)
{
- primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+ primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (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 += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+ bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
return bufferSize;
}
-CsrUint8* CsrWifiSmeMibGetNextCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeMibGetNextCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetNextCfm));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
if (primitive->mibAttributeLength)
{
- primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+ primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
}
else
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 1; /* CsrBool primitive->secondFailure */
bufferSize += 2; /* CsrUint16 primitive->count */
- bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ bufferSize += 6; /* u8 primitive->address.a[6] */
bufferSize += 1; /* CsrWifiSmeKeyType primitive->keyType */
return bufferSize;
}
-CsrUint8* CsrWifiSmeMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMicFailureInd *primitive = (CsrWifiSmeMicFailureInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->secondFailure);
+ CsrUint8Ser(ptr, len, (u8) primitive->secondFailure);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->count);
CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->keyType);
+ CsrUint8Ser(ptr, len, (u8) primitive->keyType);
return(ptr);
}
-void* CsrWifiSmeMicFailureIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMicFailureIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMicFailureInd *primitive = (CsrWifiSmeMicFailureInd *) CsrPmemAlloc(sizeof(CsrWifiSmeMicFailureInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->secondFailure, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->secondFailure, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->count, buffer, &offset);
CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->keyType, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->keyType, buffer, &offset);
return primitive;
}
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
- bufferSize += 1; /* CsrUint8 primitive->getAddressesCount */
+ bufferSize += 1; /* u8 primitive->getAddressesCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->getAddresses[i1].a[6] */
+ bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmeMulticastAddressCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->getAddressesCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->action);
+ CsrUint8Ser(ptr, len, (u8) primitive->getAddressesCount);
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
}
-void* CsrWifiSmeMulticastAddressCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMulticastAddressCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->getAddressesCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->getAddressesCount, buffer, &offset);
primitive->getAddresses = NULL;
if (primitive->getAddressesCount)
{
}
-CsrUint8* CsrWifiSmePacketFilterSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmePacketFilterSetCfm *primitive = (CsrWifiSmePacketFilterSetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmePacketFilterSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmePacketFilterSetCfm *primitive = (CsrWifiSmePacketFilterSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePacketFilterSetCfm));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 6; /* CsrUint8 primitive->permanentMacAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->permanentMacAddress.a[6] */
return bufferSize;
}
-CsrUint8* CsrWifiSmePermanentMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmePermanentMacAddressGetCfm *primitive = (CsrWifiSmePermanentMacAddressGetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmePermanentMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmePermanentMacAddressGetCfm *primitive = (CsrWifiSmePermanentMacAddressGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePermanentMacAddressGetCfm));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
- bufferSize += 1; /* CsrUint8 primitive->pmkidCandidatesCount */
+ bufferSize += 1; /* u8 primitive->pmkidCandidatesCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->pmkidCandidates[i1].bssid.a[6] */
+ bufferSize += 6; /* u8 primitive->pmkidCandidates[i1].bssid.a[6] */
bufferSize += 1; /* CsrBool primitive->pmkidCandidates[i1].preAuthAllowed */
}
}
}
-CsrUint8* CsrWifiSmePmkidCandidateListIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->pmkidCandidatesCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->pmkidCandidatesCount);
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
{
CsrMemCpySer(ptr, len, (const void *) primitive->pmkidCandidates[i1].bssid.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->pmkidCandidates[i1].preAuthAllowed);
+ CsrUint8Ser(ptr, len, (u8) primitive->pmkidCandidates[i1].preAuthAllowed);
}
}
return(ptr);
}
-void* CsrWifiSmePmkidCandidateListIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidCandidateListInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->pmkidCandidatesCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->pmkidCandidatesCount, buffer, &offset);
primitive->pmkidCandidates = NULL;
if (primitive->pmkidCandidatesCount)
{
for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
{
CsrMemCpyDes(primitive->pmkidCandidates[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->pmkidCandidates[i1].preAuthAllowed, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->pmkidCandidates[i1].preAuthAllowed, buffer, &offset);
}
}
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
- bufferSize += 1; /* CsrUint8 primitive->getPmkidsCount */
+ bufferSize += 1; /* u8 primitive->getPmkidsCount */
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->getPmkids[i1].bssid.a[6] */
- bufferSize += 16; /* CsrUint8 primitive->getPmkids[i1].pmkid[16] */
+ bufferSize += 6; /* u8 primitive->getPmkids[i1].bssid.a[6] */
+ bufferSize += 16; /* u8 primitive->getPmkids[i1].pmkid[16] */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmePmkidCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePmkidCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->getPmkidsCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->action);
+ CsrUint8Ser(ptr, len, (u8) primitive->getPmkidsCount);
{
CsrUint16 i1;
for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
}
-void* CsrWifiSmePmkidCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePmkidCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->getPmkidsCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->getPmkidsCount, buffer, &offset);
primitive->getPmkids = NULL;
if (primitive->getPmkidsCount)
{
bufferSize += 2; /* CsrUint16 primitive->powerConfig.listenIntervalTu */
bufferSize += 1; /* CsrBool primitive->powerConfig.rxDtims */
bufferSize += 1; /* CsrWifiSmeD3AutoScanMode primitive->powerConfig.d3AutoScanMode */
- bufferSize += 1; /* CsrUint8 primitive->powerConfig.clientTrafficWindow */
+ bufferSize += 1; /* u8 primitive->powerConfig.clientTrafficWindow */
bufferSize += 1; /* CsrBool primitive->powerConfig.opportunisticPowerSave */
bufferSize += 1; /* CsrBool primitive->powerConfig.noticeOfAbsence */
return bufferSize;
}
-CsrUint8* CsrWifiSmePowerConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmePowerConfigGetCfm *primitive = (CsrWifiSmePowerConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.powerSaveLevel);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.powerSaveLevel);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->powerConfig.listenIntervalTu);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.rxDtims);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.d3AutoScanMode);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.clientTrafficWindow);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.opportunisticPowerSave);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.noticeOfAbsence);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.rxDtims);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.d3AutoScanMode);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.clientTrafficWindow);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.opportunisticPowerSave);
+ CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.noticeOfAbsence);
return(ptr);
}
-void* CsrWifiSmePowerConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmePowerConfigGetCfm *primitive = (CsrWifiSmePowerConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.opportunisticPowerSave, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->powerConfig.noticeOfAbsence, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.opportunisticPowerSave, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->powerConfig.noticeOfAbsence, buffer, &offset);
return primitive;
}
bufferSize += 1; /* CsrBool primitive->regDomInfo.dot11MultiDomainCapabilityImplemented */
bufferSize += 1; /* CsrBool primitive->regDomInfo.dot11MultiDomainCapabilityEnabled */
bufferSize += 1; /* CsrWifiSmeRegulatoryDomain primitive->regDomInfo.currentRegulatoryDomain */
- bufferSize += 2; /* CsrUint8 primitive->regDomInfo.currentCountryCode[2] */
+ bufferSize += 2; /* u8 primitive->regDomInfo.currentCountryCode[2] */
return bufferSize;
}
-CsrUint8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeRegulatoryDomainInfoGetCfm *primitive = (CsrWifiSmeRegulatoryDomainInfoGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->regDomInfo.dot11MultiDomainCapabilityImplemented);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->regDomInfo.dot11MultiDomainCapabilityEnabled);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->regDomInfo.currentRegulatoryDomain);
+ 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)));
return(ptr);
}
-void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeRegulatoryDomainInfoGetCfm *primitive = (CsrWifiSmeRegulatoryDomainInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRegulatoryDomainInfoGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityImplemented, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityEnabled, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->regDomInfo.currentRegulatoryDomain, 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)));
return primitive;
}
-CsrUint8* CsrWifiSmeRoamCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeRoamCompleteInd *primitive = (CsrWifiSmeRoamCompleteInd *)msg;
*len = 0;
}
-void* CsrWifiSmeRoamCompleteIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeRoamCompleteInd *primitive = (CsrWifiSmeRoamCompleteInd *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamCompleteInd));
CsrSize offset;
}
-CsrUint8* CsrWifiSmeRoamStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeRoamStartInd *primitive = (CsrWifiSmeRoamStartInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamReason);
+ CsrUint8Ser(ptr, len, (u8) primitive->roamReason);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->reason80211);
return(ptr);
}
-void* CsrWifiSmeRoamStartIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamStartIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeRoamStartInd *primitive = (CsrWifiSmeRoamStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamStartInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->roamReason, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->roamReason, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->reason80211, buffer, &offset);
return primitive;
}
bufferSize += 1; /* CsrBool primitive->roamingConfig.disableSmoothRoaming */
bufferSize += 1; /* CsrBool primitive->roamingConfig.disableRoamScans */
- bufferSize += 1; /* CsrUint8 primitive->roamingConfig.reconnectLimit */
+ bufferSize += 1; /* u8 primitive->roamingConfig.reconnectLimit */
bufferSize += 2; /* CsrUint16 primitive->roamingConfig.reconnectLimitIntervalMs */
{
CsrUint16 i2;
}
-CsrUint8* CsrWifiSmeRoamingConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeRoamingConfigGetCfm *primitive = (CsrWifiSmeRoamingConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
}
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableSmoothRoaming);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableRoamScans);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.reconnectLimit);
+ 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);
{
CsrUint16 i2;
}
-void* CsrWifiSmeRoamingConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeRoamingConfigGetCfm *primitive = (CsrWifiSmeRoamingConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigGetCfm));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
}
}
- CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.reconnectLimit, 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);
{
CsrUint16 i2;
}
-CsrUint8* CsrWifiSmeRoamingConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeRoamingConfigSetCfm *primitive = (CsrWifiSmeRoamingConfigSetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeRoamingConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeRoamingConfigSetCfm *primitive = (CsrWifiSmeRoamingConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigSetCfm));
CsrSize offset;
bufferSize += 1; /* CsrInt8 primitive->scanConfig.lowSnrThreshold */
bufferSize += 1; /* CsrInt8 primitive->scanConfig.deltaSnrThreshold */
bufferSize += 2; /* CsrUint16 primitive->scanConfig.passiveChannelListCount */
- bufferSize += primitive->scanConfig.passiveChannelListCount; /* CsrUint8 primitive->scanConfig.passiveChannelList */
+ bufferSize += primitive->scanConfig.passiveChannelListCount; /* u8 primitive->scanConfig.passiveChannelList */
return bufferSize;
}
-CsrUint8* CsrWifiSmeScanConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
}
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.disableAutonomousScans);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.disableAutonomousScans);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.maxResults);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highRssiThreshold);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowRssiThreshold);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaRssiThreshold);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highSnrThreshold);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowSnrThreshold);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaSnrThreshold);
+ 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);
if (primitive->scanConfig.passiveChannelListCount)
{
}
-void* CsrWifiSmeScanConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigGetCfm));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
}
}
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->scanConfig.maxResults, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaSnrThreshold, 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);
if (primitive->scanConfig.passiveChannelListCount)
{
- primitive->scanConfig.passiveChannelList = (CsrUint8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
+ primitive->scanConfig.passiveChannelList = (u8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
}
else
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 149) */
- bufferSize += 32; /* CsrUint8 primitive->result.ssid.ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->result.ssid.length */
- bufferSize += 6; /* CsrUint8 primitive->result.bssid.a[6] */
+ bufferSize += 32; /* u8 primitive->result.ssid.ssid[32] */
+ bufferSize += 1; /* u8 primitive->result.ssid.length */
+ bufferSize += 6; /* u8 primitive->result.bssid.a[6] */
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 += 8; /* CsrUint8 primitive->result.timeStamp.data[8] */
- bufferSize += 8; /* CsrUint8 primitive->result.localTime.data[8] */
+ 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 += 1; /* CsrUint8 primitive->result.channelNumber */
+ 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 += primitive->result.informationElementsLength; /* CsrUint8 primitive->result.informationElements */
+ bufferSize += primitive->result.informationElementsLength; /* u8 primitive->result.informationElements */
bufferSize += 1; /* CsrWifiSmeP2pRole primitive->result.p2pDeviceRole */
switch (primitive->result.p2pDeviceRole)
{
case CSR_WIFI_SME_P2P_ROLE_CLI:
- bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.reservedCli.empty */
+ bufferSize += 1; /* u8 primitive->result.deviceInfo.reservedCli.empty */
break;
case CSR_WIFI_SME_P2P_ROLE_GO:
bufferSize += 1; /* CsrWifiSmeP2pGroupCapabilityMask primitive->result.deviceInfo.groupInfo.groupCapability */
- bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
- bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2pClientInfoCount */
+ bufferSize += 6; /* u8 primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
+ bufferSize += 1; /* u8 primitive->result.deviceInfo.groupInfo.p2pClientInfoCount */
{
CsrUint16 i4;
for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
- bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
- bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a[6] */
bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods */
bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap */
- bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
- bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
+ 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;
for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
{
- bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
+ bufferSize += 8; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
}
}
- bufferSize += 32; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName[32] */
- bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength */
+ bufferSize += 32; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName[32] */
+ bufferSize += 1; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength */
}
}
break;
case CSR_WIFI_SME_P2P_ROLE_NONE:
- bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.reservedNone.empty */
+ bufferSize += 1; /* u8 primitive->result.deviceInfo.reservedNone.empty */
break;
case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
- bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a[6] */
bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->result.deviceInfo.standalonedevInfo.configMethods */
bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap */
- bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
- bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
+ bufferSize += 8; /* u8 primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
+ bufferSize += 1; /* u8 primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
{
CsrUint16 i4;
for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
{
- bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
+ bufferSize += 8; /* u8 primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
}
}
- bufferSize += 32; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.deviceName[32] */
- bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.deviceNameLength */
+ bufferSize += 32; /* u8 primitive->result.deviceInfo.standalonedevInfo.deviceName[32] */
+ bufferSize += 1; /* u8 primitive->result.deviceInfo.standalonedevInfo.deviceNameLength */
break;
default:
break;
}
-CsrUint8* CsrWifiSmeScanResultIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrMemCpySer(ptr, len, (const void *) primitive->result.ssid.ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.ssid.length);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.ifIndex);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.channelNumber);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.usability);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.bssType);
+ 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);
if (primitive->result.informationElementsLength)
{
CsrMemCpySer(ptr, len, (const void *) primitive->result.informationElements, ((CsrUint16) (primitive->result.informationElementsLength)));
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.p2pDeviceRole);
+ CsrUint8Ser(ptr, len, (u8) primitive->result.p2pDeviceRole);
switch (primitive->result.p2pDeviceRole)
{
case CSR_WIFI_SME_P2P_ROLE_CLI:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.reservedCli.empty);
+ CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.reservedCli.empty);
break;
case CSR_WIFI_SME_P2P_ROLE_GO:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.groupCapability);
+ CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.groupCapability);
CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2pClientInfoCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2pClientInfoCount);
{
CsrUint16 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
+ 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)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
{
CsrUint16 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.deviceName, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
+ CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
}
}
break;
case CSR_WIFI_SME_P2P_ROLE_NONE:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.reservedNone.empty);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap);
+ CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap);
CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
{
CsrUint16 i4;
for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
}
}
CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceName, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.standalonedevInfo.deviceNameLength);
+ CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.deviceNameLength);
break;
default:
break;
}
-void* CsrWifiSmeScanResultIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrMemCpyDes(primitive->result.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->result.ssid.length, buffer, &offset);
+ 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);
- CsrUint8Des((CsrUint8 *) &primitive->result.ifIndex, 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);
- CsrUint8Des((CsrUint8 *) &primitive->result.channelNumber, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->result.usability, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->result.bssType, 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);
if (primitive->result.informationElementsLength)
{
- primitive->result.informationElements = (CsrUint8 *)CsrPmemAlloc(primitive->result.informationElementsLength);
+ primitive->result.informationElements = (u8 *)CsrPmemAlloc(primitive->result.informationElementsLength);
CsrMemCpyDes(primitive->result.informationElements, buffer, &offset, ((CsrUint16) (primitive->result.informationElementsLength)));
}
else
{
primitive->result.informationElements = NULL;
}
- CsrUint8Des((CsrUint8 *) &primitive->result.p2pDeviceRole, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->result.p2pDeviceRole, buffer, &offset);
switch (primitive->result.p2pDeviceRole)
{
case CSR_WIFI_SME_P2P_ROLE_CLI:
- CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.reservedCli.empty, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->result.deviceInfo.reservedCli.empty, buffer, &offset);
break;
case CSR_WIFI_SME_P2P_ROLE_GO:
- CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.groupCapability, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.groupCapability, buffer, &offset);
CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
primitive->result.deviceInfo.groupInfo.p2PClientInfo = NULL;
if (primitive->result.deviceInfo.groupInfo.p2pClientInfoCount)
{
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);
- CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, 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)));
- CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
+ 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)
{
}
}
CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
}
}
break;
case CSR_WIFI_SME_P2P_ROLE_NONE:
- CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.reservedNone.empty, 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);
- CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
- CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
primitive->result.deviceInfo.standalonedevInfo.secDeviceType = NULL;
if (primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount)
{
}
}
CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
break;
default:
break;
CsrUint16 i1;
for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
{
- bufferSize += 32; /* CsrUint8 primitive->scanResults[i1].ssid.ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].ssid.length */
- bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].bssid.a[6] */
+ bufferSize += 32; /* u8 primitive->scanResults[i1].ssid.ssid[32] */
+ bufferSize += 1; /* u8 primitive->scanResults[i1].ssid.length */
+ bufferSize += 6; /* u8 primitive->scanResults[i1].bssid.a[6] */
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 += 8; /* CsrUint8 primitive->scanResults[i1].timeStamp.data[8] */
- bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].localTime.data[8] */
+ 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 += 1; /* CsrUint8 primitive->scanResults[i1].channelNumber */
+ 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 += primitive->scanResults[i1].informationElementsLength; /* CsrUint8 primitive->scanResults[i1].informationElements */
+ bufferSize += primitive->scanResults[i1].informationElementsLength; /* u8 primitive->scanResults[i1].informationElements */
bufferSize += 1; /* CsrWifiSmeP2pRole primitive->scanResults[i1].p2pDeviceRole */
switch (primitive->scanResults[i1].p2pDeviceRole)
{
case CSR_WIFI_SME_P2P_ROLE_CLI:
- bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.reservedCli.empty */
+ bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.reservedCli.empty */
break;
case CSR_WIFI_SME_P2P_ROLE_GO:
bufferSize += 1; /* CsrWifiSmeP2pGroupCapabilityMask primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability */
- bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
- bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount */
+ bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
+ bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount */
{
CsrUint16 i4;
for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
{
- bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
- bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a[6] */
bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods */
bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap */
- bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
- bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
+ 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;
for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
{
- bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
+ bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
}
}
- bufferSize += 32; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName[32] */
- bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength */
+ bufferSize += 32; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName[32] */
+ bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength */
}
}
break;
case CSR_WIFI_SME_P2P_ROLE_NONE:
- bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.reservedNone.empty */
+ bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.reservedNone.empty */
break;
case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
- bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a[6] */
+ bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a[6] */
bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods */
bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap */
- bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
- bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
+ bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
+ bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
{
CsrUint16 i4;
for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
{
- bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
+ bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
}
}
- bufferSize += 32; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName[32] */
- bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength */
+ bufferSize += 32; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName[32] */
+ bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength */
break;
default:
break;
}
-CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *)msg;
*len = 0;
for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
{
CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].ssid.ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].ssid.length);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].ifIndex);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].channelNumber);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].usability);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].bssType);
+ 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);
if (primitive->scanResults[i1].informationElementsLength)
{
CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].informationElements, ((CsrUint16) (primitive->scanResults[i1].informationElementsLength)));
}
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].p2pDeviceRole);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].p2pDeviceRole);
switch (primitive->scanResults[i1].p2pDeviceRole)
{
case CSR_WIFI_SME_P2P_ROLE_CLI:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.reservedCli.empty);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.reservedCli.empty);
break;
case CSR_WIFI_SME_P2P_ROLE_GO:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability);
CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, ((CsrUint16) (6)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount);
{
CsrUint16 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
+ 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)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
{
CsrUint16 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.deviceName, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
}
}
break;
case CSR_WIFI_SME_P2P_ROLE_NONE:
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.reservedNone.empty);
+ 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);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap);
CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
{
CsrUint16 i4;
for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
}
}
CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength);
+ CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength);
break;
default:
break;
}
-void* CsrWifiSmeScanResultsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultsGetCfm));
CsrSize offset;
for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
{
CsrMemCpyDes(primitive->scanResults[i1].ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].ssid.length, buffer, &offset);
+ 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);
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].ifIndex, 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);
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].channelNumber, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].usability, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].bssType, 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);
if (primitive->scanResults[i1].informationElementsLength)
{
- primitive->scanResults[i1].informationElements = (CsrUint8 *)CsrPmemAlloc(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)));
}
else
{
primitive->scanResults[i1].informationElements = NULL;
}
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].p2pDeviceRole, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanResults[i1].p2pDeviceRole, buffer, &offset);
switch (primitive->scanResults[i1].p2pDeviceRole)
{
case CSR_WIFI_SME_P2P_ROLE_CLI:
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.reservedCli.empty, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.reservedCli.empty, buffer, &offset);
break;
case CSR_WIFI_SME_P2P_ROLE_GO:
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability, buffer, &offset);
CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo = NULL;
if (primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount)
{
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);
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, 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)));
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
+ 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)
{
}
}
CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
}
}
break;
case CSR_WIFI_SME_P2P_ROLE_NONE:
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.reservedNone.empty, 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);
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType = NULL;
if (primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount)
{
}
}
CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
break;
default:
break;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
- bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
+ bufferSize += 1; /* u8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
+ bufferSize += 1; /* u8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
bufferSize += 1; /* CsrWifiSmeWmmModeMask primitive->smeConfig.wmmModeMask */
bufferSize += 1; /* CsrWifiSmeRadioIF primitive->smeConfig.ifIndex */
bufferSize += 1; /* CsrBool primitive->smeConfig.allowUnicastUseGroupCipher */
}
-CsrUint8* CsrWifiSmeSmeStaConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeSmeStaConfigGetCfm *primitive = (CsrWifiSmeSmeStaConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.wmmModeMask);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.ifIndex);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.allowUnicastUseGroupCipher);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.enableOpportunisticKeyCaching);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.wmmModeMask);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.ifIndex);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.allowUnicastUseGroupCipher);
+ CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.enableOpportunisticKeyCaching);
return(ptr);
}
-void* CsrWifiSmeSmeStaConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeSmeStaConfigGetCfm *primitive = (CsrWifiSmeSmeStaConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.ifIndex, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.allowUnicastUseGroupCipher, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->smeConfig.enableOpportunisticKeyCaching, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.ifIndex, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.allowUnicastUseGroupCipher, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->smeConfig.enableOpportunisticKeyCaching, buffer, &offset);
return primitive;
}
}
-CsrUint8* CsrWifiSmeSmeStaConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeSmeStaConfigSetCfm *primitive = (CsrWifiSmeSmeStaConfigSetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeSmeStaConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeSmeStaConfigSetCfm *primitive = (CsrWifiSmeSmeStaConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigSetCfm));
CsrSize offset;
CsrUint16 i1;
for (i1 = 0; i1 < 2; i1++)
{
- bufferSize += 6; /* CsrUint8 primitive->stationMacAddress[i1].a[6] */
+ bufferSize += 6; /* u8 primitive->stationMacAddress[i1].a[6] */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmeStationMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeStationMacAddressGetCfm *primitive = (CsrWifiSmeStationMacAddressGetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeStationMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeStationMacAddressGetCfm *primitive = (CsrWifiSmeStationMacAddressGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeStationMacAddressGetCfm));
CsrSize offset;
bufferSize += 4; /* CsrUint32 primitive->transactionId */
bufferSize += 1; /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
bufferSize += 2; /* CsrUint16 primitive->tspecLength */
- bufferSize += primitive->tspecLength; /* CsrUint8 primitive->tspec */
+ bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
return bufferSize;
}
-CsrUint8* CsrWifiSmeTspecIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeTspecIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->tspecResultCode);
+ CsrUint8Ser(ptr, len, (u8) primitive->tspecResultCode);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
if (primitive->tspecLength)
{
}
-void* CsrWifiSmeTspecIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeTspecIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecInd));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->tspecResultCode, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->tspecResultCode, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
if (primitive->tspecLength)
{
- primitive->tspec = (CsrUint8 *)CsrPmemAlloc(primitive->tspecLength);
+ primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
}
else
bufferSize += 4; /* CsrUint32 primitive->transactionId */
bufferSize += 1; /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
bufferSize += 2; /* CsrUint16 primitive->tspecLength */
- bufferSize += primitive->tspecLength; /* CsrUint8 primitive->tspec */
+ bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
return bufferSize;
}
-CsrUint8* CsrWifiSmeTspecCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeTspecCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->tspecResultCode);
+ CsrUint8Ser(ptr, len, (u8) primitive->tspecResultCode);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
if (primitive->tspecLength)
{
}
-void* CsrWifiSmeTspecCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeTspecCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecCfm));
CsrSize offset;
CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->tspecResultCode, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->tspecResultCode, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
if (primitive->tspecLength)
{
- primitive->tspec = (CsrUint8 *)CsrPmemAlloc(primitive->tspecLength);
+ primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
}
else
}
-CsrUint8* CsrWifiSmeVersionsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeVersionsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeVersionsGetCfm));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 39) */
bufferSize += 2; /* CsrResult primitive->status */
- bufferSize += 1; /* CsrUint8 primitive->cloakedSsids.cloakedSsidsCount */
+ bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsidsCount */
{
CsrUint16 i2;
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
- bufferSize += 32; /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
- bufferSize += 1; /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].length */
+ bufferSize += 32; /* u8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
+ bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsids[i2].length */
}
}
return bufferSize;
}
-CsrUint8* CsrWifiSmeCloakedSsidsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsidsCount);
+ CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsidsCount);
{
CsrUint16 i2;
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((CsrUint16) (32)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsids[i2].length);
+ CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsids[i2].length);
}
}
return(ptr);
}
-void* CsrWifiSmeCloakedSsidsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
primitive->cloakedSsids.cloakedSsids = NULL;
if (primitive->cloakedSsids.cloakedSsidsCount)
{
for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
{
CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((CsrUint16) (32)));
- CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
}
}
CsrSize bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
- bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ bufferSize += 6; /* u8 primitive->address.a[6] */
return bufferSize;
}
-CsrUint8* CsrWifiSmeWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeWifiOnInd *primitive = (CsrWifiSmeWifiOnInd *)msg;
*len = 0;
}
-void* CsrWifiSmeWifiOnIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeWifiOnIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeWifiOnInd *primitive = (CsrWifiSmeWifiOnInd *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnInd));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
bufferSize += 2; /* CsrResult primitive->status */
bufferSize += 1; /* CsrWifiSme80211dTrustLevel primitive->deviceConfig.trustLevel */
- bufferSize += 2; /* CsrUint8 primitive->deviceConfig.countryCode[2] */
+ bufferSize += 2; /* u8 primitive->deviceConfig.countryCode[2] */
bufferSize += 1; /* CsrWifiSmeFirmwareDriverInterface primitive->deviceConfig.firmwareDriverInterface */
bufferSize += 1; /* CsrBool primitive->deviceConfig.enableStrictDraftN */
return bufferSize;
}
-CsrUint8* CsrWifiSmeSmeCommonConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeSmeCommonConfigGetCfm *primitive = (CsrWifiSmeSmeCommonConfigGetCfm *)msg;
*len = 0;
CsrUint16Ser(ptr, len, primitive->common.type);
CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.trustLevel);
+ CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.trustLevel);
CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((CsrUint16) (2)));
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.firmwareDriverInterface);
- CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.enableStrictDraftN);
+ CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.firmwareDriverInterface);
+ CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.enableStrictDraftN);
return(ptr);
}
-void* CsrWifiSmeSmeCommonConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeSmeCommonConfigGetCfm *primitive = (CsrWifiSmeSmeCommonConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigGetCfm));
CsrSize offset;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((CsrUint16) (2)));
- CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
- CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
+ CsrUint8Des((u8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
return primitive;
}
/* 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; /* CsrUint8 primitive->capBitmap[2] */
+ bufferSize += 2; /* u8 primitive->capBitmap[2] */
return bufferSize;
}
-CsrUint8* CsrWifiSmeInterfaceCapabilityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeInterfaceCapabilityGetCfm *primitive = (CsrWifiSmeInterfaceCapabilityGetCfm *)msg;
*len = 0;
}
-void* CsrWifiSmeInterfaceCapabilityGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeInterfaceCapabilityGetCfm *primitive = (CsrWifiSmeInterfaceCapabilityGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeInterfaceCapabilityGetCfm));
CsrSize offset;
}
-CsrUint8* CsrWifiSmeErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeErrorIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *)msg;
*len = 0;
}
-void* CsrWifiSmeErrorIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeErrorIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *) CsrPmemAlloc(sizeof(CsrWifiSmeErrorInd));
CsrSize offset;
}
-CsrUint8* CsrWifiSmeInfoIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeInfoIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *)msg;
*len = 0;
}
-void* CsrWifiSmeInfoIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeInfoIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *) CsrPmemAlloc(sizeof(CsrWifiSmeInfoInd));
CsrSize offset;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 4; /* CsrUint32 primitive->dataLength */
- bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ bufferSize += primitive->dataLength; /* u8 primitive->data */
return bufferSize;
}
-CsrUint8* CsrWifiSmeCoreDumpIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, CsrSize *len, void *msg)
{
CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *)msg;
*len = 0;
}
-void* CsrWifiSmeCoreDumpIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, CsrSize length)
{
CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *) CsrPmemAlloc(sizeof(CsrWifiSmeCoreDumpInd));
CsrSize offset;
CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
if (primitive->dataLength)
{
- primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
}
else
#define CsrWifiSmeAdhocConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeAdhocConfigGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeAdhocConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAdhocConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeAdhocConfigSetReqSizeof(void *msg);
#define CsrWifiSmeAdhocConfigSetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeBlacklistReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeBlacklistReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeBlacklistReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeBlacklistReqSizeof(void *msg);
extern void CsrWifiSmeBlacklistReqSerFree(void *msg);
#define CsrWifiSmeCalibrationDataGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeCalibrationDataGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeCalibrationDataSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCalibrationDataSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCalibrationDataSetReqSizeof(void *msg);
extern void CsrWifiSmeCalibrationDataSetReqSerFree(void *msg);
#define CsrWifiSmeCcxConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeCcxConfigGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeCcxConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCcxConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg);
#define CsrWifiSmeCcxConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeCoexConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeCoexConfigGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeCoexConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoexConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg);
#define CsrWifiSmeCoexConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeCoexInfoGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeCoexInfoGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeConnectReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectReqSizeof(void *msg);
extern void CsrWifiSmeConnectReqSerFree(void *msg);
#define CsrWifiSmeHostConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeHostConfigGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeHostConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeHostConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeHostConfigSetReqSizeof(void *msg);
#define CsrWifiSmeHostConfigSetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeKeyReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeKeyReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeKeyReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeKeyReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeKeyReqSizeof(void *msg);
#define CsrWifiSmeKeyReqSerFree CsrWifiSmePfree
#define CsrWifiSmeMibConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeMibConfigGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeMibConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibConfigSetReqSizeof(void *msg);
#define CsrWifiSmeMibConfigSetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeMibGetNextReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetNextReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibGetNextReqSizeof(void *msg);
extern void CsrWifiSmeMibGetNextReqSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeMibGetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibGetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibGetReqSizeof(void *msg);
extern void CsrWifiSmeMibGetReqSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeMibSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibSetReqSizeof(void *msg);
extern void CsrWifiSmeMibSetReqSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeMulticastAddressReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMulticastAddressReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMulticastAddressReqSizeof(void *msg);
extern void CsrWifiSmeMulticastAddressReqSerFree(void *msg);
-extern CsrUint8* CsrWifiSmePacketFilterSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePacketFilterSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePacketFilterSetReqSizeof(void *msg);
extern void CsrWifiSmePacketFilterSetReqSerFree(void *msg);
#define CsrWifiSmePermanentMacAddressGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmePermanentMacAddressGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmePmkidReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePmkidReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePmkidReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePmkidReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePmkidReqSizeof(void *msg);
extern void CsrWifiSmePmkidReqSerFree(void *msg);
#define CsrWifiSmePowerConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmePowerConfigGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmePowerConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePowerConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg);
#define CsrWifiSmePowerConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeRoamingConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeRoamingConfigGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeRoamingConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamingConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg);
#define CsrWifiSmeRoamingConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeScanConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeScanConfigGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeScanConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeScanConfigSetReqSizeof(void *msg);
extern void CsrWifiSmeScanConfigSetReqSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeScanFullReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanFullReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeScanFullReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanFullReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeScanFullReqSizeof(void *msg);
extern void CsrWifiSmeScanFullReqSerFree(void *msg);
#define CsrWifiSmeSmeStaConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeSmeStaConfigGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeSmeStaConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeStaConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg);
#define CsrWifiSmeSmeStaConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeStationMacAddressGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeStationMacAddressGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeTspecReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeTspecReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeTspecReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeTspecReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeTspecReqSizeof(void *msg);
extern void CsrWifiSmeTspecReqSerFree(void *msg);
#define CsrWifiSmeVersionsGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeVersionsGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeWifiFlightmodeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWifiFlightmodeReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeWifiFlightmodeReqSizeof(void *msg);
extern void CsrWifiSmeWifiFlightmodeReqSerFree(void *msg);
#define CsrWifiSmeWifiOffReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeWifiOffReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWifiOnReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWifiOnReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeWifiOnReqSizeof(void *msg);
extern void CsrWifiSmeWifiOnReqSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeCloakedSsidsSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCloakedSsidsSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg);
extern void CsrWifiSmeCloakedSsidsSetReqSerFree(void *msg);
#define CsrWifiSmeSmeCommonConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeSmeCommonConfigGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeSmeCommonConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeCommonConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg);
#define CsrWifiSmeSmeCommonConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeInterfaceCapabilityGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeInterfaceCapabilityGetReqSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeWpsConfigurationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWpsConfigurationReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeWpsConfigurationReqSizeof(void *msg);
extern void CsrWifiSmeWpsConfigurationReqSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSetReqSizeof(void *msg);
extern void CsrWifiSmeSetReqSerFree(void *msg);
#define CsrWifiSmeActivateCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeActivateCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeAdhocConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAdhocConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeAdhocConfigGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeAdhocConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeAdhocConfigSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeAssociationCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg);
extern void CsrWifiSmeAssociationCompleteIndSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeAssociationStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAssociationStartIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeAssociationStartIndSizeof(void *msg);
#define CsrWifiSmeAssociationStartIndSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeBlacklistCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeBlacklistCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeBlacklistCfmSizeof(void *msg);
extern void CsrWifiSmeBlacklistCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeCalibrationDataGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCalibrationDataGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg);
extern void CsrWifiSmeCalibrationDataGetCfmSerFree(void *msg);
#define CsrWifiSmeCalibrationDataSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeCalibrationDataSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeCcxConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCcxConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCcxConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeCcxConfigGetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeCcxConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCcxConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCcxConfigSetCfmSizeof(void *msg);
#define CsrWifiSmeCcxConfigSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeCoexConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoexConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeCoexConfigGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeCoexConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeCoexConfigSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeCoexInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoexInfoGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCoexInfoGetCfmSizeof(void *msg);
#define CsrWifiSmeCoexInfoGetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeConnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectCfmSizeof(void *msg);
#define CsrWifiSmeConnectCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeConnectionConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg);
extern void CsrWifiSmeConnectionConfigGetCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeConnectionInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg);
extern void CsrWifiSmeConnectionInfoGetCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeConnectionQualityIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionQualityIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectionQualityIndSizeof(void *msg);
#define CsrWifiSmeConnectionQualityIndSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeConnectionStatsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionStatsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg);
#define CsrWifiSmeConnectionStatsGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeDeactivateCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeDeactivateCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeDisconnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeDisconnectCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg);
#define CsrWifiSmeDisconnectCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeEventMaskSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeEventMaskSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeHostConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeHostConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeHostConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeHostConfigGetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeHostConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeHostConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeHostConfigSetCfmSizeof(void *msg);
#define CsrWifiSmeHostConfigSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeIbssStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeIbssStationIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeIbssStationIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeIbssStationIndSizeof(void *msg);
#define CsrWifiSmeIbssStationIndSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeKeyCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeKeyCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeKeyCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeKeyCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeKeyCfmSizeof(void *msg);
#define CsrWifiSmeKeyCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeLinkQualityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeLinkQualityGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeLinkQualityGetCfmSizeof(void *msg);
#define CsrWifiSmeLinkQualityGetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeMediaStatusIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg);
extern void CsrWifiSmeMediaStatusIndSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeMibConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeMibConfigGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeMibConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeMibConfigSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeMibGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibGetCfmSizeof(void *msg);
extern void CsrWifiSmeMibGetCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeMibGetNextCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetNextCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibGetNextCfmSizeof(void *msg);
extern void CsrWifiSmeMibGetNextCfmSerFree(void *msg);
#define CsrWifiSmeMibSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeMibSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMicFailureIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMicFailureIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMicFailureIndSizeof(void *msg);
#define CsrWifiSmeMicFailureIndSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeMulticastAddressCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMulticastAddressCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMulticastAddressCfmSizeof(void *msg);
extern void CsrWifiSmeMulticastAddressCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiSmePacketFilterSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePacketFilterSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePacketFilterSetCfmSizeof(void *msg);
#define CsrWifiSmePacketFilterSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmePermanentMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePermanentMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg);
#define CsrWifiSmePermanentMacAddressGetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmePmkidCandidateListIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePmkidCandidateListIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg);
extern void CsrWifiSmePmkidCandidateListIndSerFree(void *msg);
-extern CsrUint8* CsrWifiSmePmkidCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePmkidCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePmkidCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePmkidCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePmkidCfmSizeof(void *msg);
extern void CsrWifiSmePmkidCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiSmePowerConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePowerConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg);
#define CsrWifiSmePowerConfigGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmePowerConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmePowerConfigSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg);
#define CsrWifiSmeRegulatoryDomainInfoGetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeRoamCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamCompleteIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRoamCompleteIndSizeof(void *msg);
#define CsrWifiSmeRoamCompleteIndSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeRoamStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamStartIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamStartIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRoamStartIndSizeof(void *msg);
#define CsrWifiSmeRoamStartIndSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeRoamingConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamingConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeRoamingConfigGetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeRoamingConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamingConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg);
#define CsrWifiSmeRoamingConfigSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeScanConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeScanConfigGetCfmSizeof(void *msg);
extern void CsrWifiSmeScanConfigGetCfmSerFree(void *msg);
#define CsrWifiSmeScanFullCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeScanFullCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeScanResultIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanResultIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeScanResultIndSizeof(void *msg);
extern void CsrWifiSmeScanResultIndSerFree(void *msg);
#define CsrWifiSmeScanResultsFlushCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeScanResultsFlushCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanResultsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg);
extern void CsrWifiSmeScanResultsGetCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeSmeStaConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeStaConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeSmeStaConfigGetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeSmeStaConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeStaConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg);
#define CsrWifiSmeSmeStaConfigSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeStationMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeStationMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg);
#define CsrWifiSmeStationMacAddressGetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeTspecIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeTspecIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeTspecIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeTspecIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeTspecIndSizeof(void *msg);
extern void CsrWifiSmeTspecIndSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeTspecCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeTspecCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeTspecCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeTspecCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeTspecCfmSizeof(void *msg);
extern void CsrWifiSmeTspecCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeVersionsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeVersionsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeVersionsGetCfmSizeof(void *msg);
extern void CsrWifiSmeVersionsGetCfmSerFree(void *msg);
#define CsrWifiSmeCloakedSsidsSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeCloakedSsidsSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeCloakedSsidsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCloakedSsidsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg);
extern void CsrWifiSmeCloakedSsidsGetCfmSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWifiOnIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWifiOnIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeWifiOnIndSizeof(void *msg);
#define CsrWifiSmeWifiOnIndSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeSmeCommonConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeCommonConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeSmeCommonConfigGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeSmeCommonConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeSmeCommonConfigSetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeInterfaceCapabilityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeInterfaceCapabilityGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg);
#define CsrWifiSmeInterfaceCapabilityGetCfmSerFree CsrWifiSmePfree
-extern CsrUint8* CsrWifiSmeErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeErrorIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeErrorIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeErrorIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeErrorIndSizeof(void *msg);
extern void CsrWifiSmeErrorIndSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeInfoIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeInfoIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeInfoIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeInfoIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeInfoIndSizeof(void *msg);
extern void CsrWifiSmeInfoIndSerFree(void *msg);
-extern CsrUint8* CsrWifiSmeCoreDumpIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoreDumpIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCoreDumpIndSizeof(void *msg);
extern void CsrWifiSmeCoreDumpIndSerFree(void *msg);
/* MACROS *******************************************************************/
/* Common macros for NME and SME to be used temporarily until SoftMAC changes are made */
-#define CSR_WIFI_NUM_INTERFACES (CsrUint8)0x1
+#define CSR_WIFI_NUM_INTERFACES (u8)0x1
#define CSR_WIFI_INTERFACE_IN_USE (CsrUint16)0x0
/* This is used at places where interface Id isn't available*/
/* Extract the Interface Id from the event */
#define CsrWifiVifUtilsGetVifTagFromEvent(msg) \
- ((CsrUint16) * ((CsrUint16 *) ((CsrUint8 *) (msg) + sizeof(CsrWifiFsmEvent))))
+ ((CsrUint16) * ((CsrUint16 *) ((u8 *) (msg) + sizeof(CsrWifiFsmEvent))))
/* The HPI Vif combines the type and the interface id */
#define CsrWifiVifUtilsGetVifTagFromHipEvent(msg) \
* First checks if the mode is supported capability bitmap of the interface.
* If this succeeds, then checks if running this mode on this interface is allowed.
*
- * @param[in] CsrUint8 : interface capability bitmap
- * @param[in] CsrUint8* : pointer to the array of current interface modes
+ * @param[in] u8 : interface capability bitmap
+ * @param[in] u8* : pointer to the array of current interface modes
* @param[in] CsrUint16 : interfaceTag
* @param[in] CsrWifiInterfaceMode : mode
*
* @return
* CsrBool : returns true if the interface is allowed to operate in the mode otherwise false.
*/
-extern CsrBool CsrWifiVifUtilsCheckCompatibility(CsrUint8 interfaceCapability,
- CsrUint8 *currentInterfaceModes,
+extern CsrBool CsrWifiVifUtilsCheckCompatibility(u8 interfaceCapability,
+ u8 *currentInterfaceModes,
CsrUint16 interfaceTag,
CsrWifiInterfaceMode mode);
CSR_PRIORITY priority = CSR_CONTENTION;
const int proto = ntohs(ehdr->h_proto);
- CsrUint8 interfaceMode = interfacePriv->interfaceMode;
+ u8 interfaceMode = interfacePriv->interfaceMode;
func_enter();
{
CSR_MA_PACKET_INDICATION *pkt_ind = (CSR_MA_PACKET_INDICATION*)&signal->u.MaPacketIndication;
int r;
- CsrUint8 i;
+ u8 i;
unifi_trace(priv, UDBG5,
"_identify_sme_ma_pkt_ind -->\n");
i,
pkt_ind->ReceptionStatus,
bulkdata->d[0].data_length,
- (CsrUint8*)bulkdata->d[0].os_data_ptr,
+ (u8*)bulkdata->d[0].os_data_ptr,
NULL,
pkt_ind->Rssi,
pkt_ind->Snr,
CSR_PRIORITY priority,
bulk_data_param_t *bulkdata,
CsrUint16 interfaceTag,
- const CsrUint8 *daddr,
- const CsrUint8 *saddr,
+ const u8 *daddr,
+ const u8 *saddr,
CsrBool protection)
{
CsrUint16 fc = 0;
- CsrUint8 qc = 0;
- CsrUint8 macHeaderLengthInBytes = MAC_HEADER_SIZE, *bufPtr = NULL;
+ u8 qc = 0;
+ u8 macHeaderLengthInBytes = MAC_HEADER_SIZE, *bufPtr = NULL;
bulk_data_param_t data_ptrs;
CsrResult csrResult;
int headroom =0;
- CsrUint8 direction = 0;
+ u8 direction = 0;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
- CsrUint8 *addressOne;
+ u8 *addressOne;
CsrBool bQosNull = false;
if (skb == NULL) {
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
bulkdata->d[0].data_length = newSkb->len;
- bufPtr = (CsrUint8*)data_ptrs.d[0].os_data_ptr;
+ bufPtr = (u8*)data_ptrs.d[0].os_data_ptr;
/* The old skb will not be used again */
kfree_skb(skb);
} else {
/* headroom has sufficient size, so will get proper pointer */
- bufPtr = (CsrUint8*)skb_push(skb, macHeaderLengthInBytes);
+ bufPtr = (u8*)skb_push(skb, macHeaderLengthInBytes);
bulkdata->d[0].os_data_ptr = skb->data;
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
bulkdata->d[0].data_length = skb->len;
* the Address 1 field of 802.11 Mac header here 4 is: (sizeof(framecontrol) + sizeof (durationID))
* which is address 1 field
*/
- memcpy(peerAddress.a, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+ memcpy(peerAddress.a, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
unifi_trace(priv, UDBG5, "RA[0]=%x, RA[1]=%x, RA[2]=%x, RA[3]=%x, RA[4]=%x, RA[5]=%x\n",
peerAddress.a[0],peerAddress.a[1], peerAddress.a[2], peerAddress.a[3],
req->TransmitRate = 0;
req->HostTag = CSR_WIFI_EAPOL_M4_HOST_TAG;
/* RA address matching with address 1 of Mac header */
- memcpy(req->Ra.x, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+ memcpy(req->Ra.x, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
spin_lock(&priv->m4_lock);
/* Store the M4-PACKET.req for later */
req->TransmitRate = (CSR_RATE) 0; /* rate selected by firmware */
req->HostTag = 0xffffffff; /* Ask for a new HostTag */
/* RA address matching with address 1 of Mac header */
- memcpy(req->Ra.x, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+ memcpy(req->Ra.x, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
/* Store the M4-PACKET.req for later */
spin_lock(&priv->wapi_lock);
static void
-indicate_rx_skb(unifi_priv_t *priv, CsrUint16 ifTag, CsrUint8* dst_a, CsrUint8* src_a, struct sk_buff *skb, CSR_SIGNAL *signal,
+indicate_rx_skb(unifi_priv_t *priv, CsrUint16 ifTag, u8* dst_a, u8* src_a, struct sk_buff *skb, CSR_SIGNAL *signal,
bulk_data_param_t *bulkdata)
{
int r, sr = 0;
const CSR_MA_PACKET_INDICATION *pkt_ind = &signal->u.MaPacketIndication;
struct sk_buff *skb;
CsrWifiRouterCtrlPortAction port_action;
- CsrUint8 dataFrameType;
+ u8 dataFrameType;
int proto;
int queue;
- CsrUint8 da[ETH_ALEN], sa[ETH_ALEN];
- CsrUint8 toDs, fromDs, frameType, macHeaderLengthInBytes = MAC_HEADER_SIZE;
+ u8 da[ETH_ALEN], sa[ETH_ALEN];
+ u8 toDs, fromDs, frameType, macHeaderLengthInBytes = MAC_HEADER_SIZE;
CsrUint16 frameControl;
netInterface_priv_t *interfacePriv;
struct ethhdr ehdr;
struct sk_buff *skb;
CsrUint16 frameControl;
netInterface_priv_t *interfacePriv;
- CsrUint8 da[ETH_ALEN], sa[ETH_ALEN];
- CsrUint8 *bssid = NULL, *ba_addr = NULL;
- CsrUint8 toDs, fromDs, frameType;
- CsrUint8 i =0;
+ u8 da[ETH_ALEN], sa[ETH_ALEN];
+ u8 *bssid = NULL, *ba_addr = NULL;
+ u8 toDs, fromDs, frameType;
+ u8 i =0;
#ifdef CSR_SUPPORT_SME
- CsrUint8 dataFrameType = 0;
+ u8 dataFrameType = 0;
CsrBool powerSaveChanged = FALSE;
- CsrUint8 pmBit = 0;
+ u8 pmBit = 0;
CsrWifiRouterCtrlStaInfo_t *srcStaInfo = NULL;
CsrUint16 qosControl;
}
else
{
- bssid = (CsrUint8 *) (skb->data + 4 + 12 - (fromDs * 6) - (toDs * 12));
+ bssid = (u8 *) (skb->data + 4 + 12 - (fromDs * 6) - (toDs * 12));
}
pData = &bulkdata->d[0];
if((frameControl & 0x00f0) == 0x00A0){
/* This is a PS-POLL request */
- CsrUint8 pmBit = (frameControl & 0x1000)?0x01:0x00;
+ u8 pmBit = (frameControl & 0x1000)?0x01:0x00;
unifi_trace(priv, UDBG6, "%s: Received PS-POLL Frame\n", __FUNCTION__);
uf_process_ps_poll(priv,sa,da,pmBit,interfaceTag);
#endif
if( ((frameControl & 0x00f0) >> 4) == QOS_DATA) {
- CsrUint8 *qos_control_ptr = (CsrUint8*)bulkdata->d[0].os_data_ptr + (((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK))?30: 24);
+ u8 *qos_control_ptr = (u8*)bulkdata->d[0].os_data_ptr + (((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK))?30: 24);
int tID = *qos_control_ptr & IEEE802_11_QC_TID_MASK; /* using ls octet of qos control */
ba_session_rx_struct *ba_session;
- CsrUint8 ba_session_idx = 0;
+ u8 ba_session_idx = 0;
/* Get the BA originator address */
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO){
CsrUint32 offset;
CsrUint32 length = bulkdata->d[0].data_length;
CsrUint32 subframe_length, subframe_body_length, dot11_hdr_size;
- CsrUint8 *ptr;
+ u8 *ptr;
bulk_data_param_t subframe_bulkdata;
- CsrUint8 *dot11_hdr_ptr = (CsrUint8*)bulkdata->d[0].os_data_ptr;
+ u8 *dot11_hdr_ptr = (u8*)bulkdata->d[0].os_data_ptr;
CsrResult csrResult;
CsrUint16 frameControl;
- CsrUint8 *qos_control_ptr;
+ u8 *qos_control_ptr;
frameControl = le16_to_cpu(*((CsrUint16*)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);
break;
}
- memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr, dot11_hdr_ptr, dot11_hdr_size);
+ memcpy((u8*)subframe_bulkdata.d[0].os_data_ptr, dot11_hdr_ptr, dot11_hdr_size);
/* When to DS=0 and from DS=0, address 3 will already have BSSID so no need to re-program */
if ((frameControl & IEEE802_11_FC_TO_DS_MASK) && !(frameControl & IEEE802_11_FC_FROM_DS_MASK)){
- memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr + IEEE802_11_ADDR3_OFFSET, ((struct ethhdr*)ptr)->h_dest, ETH_ALEN);
+ memcpy((u8*)subframe_bulkdata.d[0].os_data_ptr + IEEE802_11_ADDR3_OFFSET, ((struct ethhdr*)ptr)->h_dest, ETH_ALEN);
}
else if (!(frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK)){
- memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr + IEEE802_11_ADDR3_OFFSET,
+ memcpy((u8*)subframe_bulkdata.d[0].os_data_ptr + IEEE802_11_ADDR3_OFFSET,
((struct ethhdr*)ptr)->h_source,
ETH_ALEN);
}
- memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr + dot11_hdr_size,
+ memcpy((u8*)subframe_bulkdata.d[0].os_data_ptr + dot11_hdr_size,
ptr + sizeof(struct ethhdr),
subframe_body_length);
unifi_trace(priv, UDBG6, "%s: calling unifi_rx. length = %d subframe_length = %d\n", __FUNCTION__, length, subframe_length);
static void process_ba_complete(unifi_priv_t *priv, netInterface_priv_t *interfacePriv)
{
frame_desc_struct *frame_desc;
- CsrUint8 i;
+ u8 i;
for(i = 0; i < interfacePriv->ba_complete_index; i++) {
frame_desc = &interfacePriv->ba_complete[i];
{
CsrTime now;
CsrTime age;
- CsrUint8 i, j;
+ u8 i, j;
CsrUint16 sn_temp;
/* gap is started at 1 because we have buffered frames and
* hence a minimum gap of 1 exists
*/
- CsrUint8 gap=1;
+ u8 gap=1;
now = CsrTimeGet(NULL);
const CSR_MA_PACKET_ERROR_INDICATION *pkt_err_ind = &signal->u.MaPacketErrorIndication;
netInterface_priv_t *interfacePriv;
ba_session_rx_struct *ba_session;
- CsrUint8 ba_session_idx = 0;
+ u8 ba_session_idx = 0;
CSR_PRIORITY UserPriority;
CSR_SEQUENCE_NUMBER sn;
int unifi_putest_cmd52_read(unifi_priv_t *priv, unsigned char *arg)
{
struct unifi_putest_cmd52 cmd52_params;
- CsrUint8 *arg_pos;
+ u8 *arg_pos;
unsigned int cmd_param_size;
int r;
CsrResult csrResult;
unsigned char ret_buffer[32];
- CsrUint8 *ret_buffer_pos;
- CsrUint8 retries;
+ u8 *ret_buffer_pos;
+ u8 retries;
- arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+ arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1);
if (get_user(cmd_param_size, (int*)arg_pos)) {
unifi_error(priv,
"unifi_putest_cmd52_read: Failed to get the argument\n");
/* Copy the info to the out buffer */
*(unifi_putest_command_t*)ret_buffer = UNIFI_PUTEST_CMD52_READ;
- ret_buffer_pos = (CsrUint8*)(((unifi_putest_command_t*)ret_buffer) + 1);
+ ret_buffer_pos = (u8*)(((unifi_putest_command_t*)ret_buffer) + 1);
*(unsigned int*)ret_buffer_pos = sizeof(struct unifi_putest_cmd52);
ret_buffer_pos += sizeof(unsigned int);
memcpy(ret_buffer_pos, &cmd52_params, sizeof(struct unifi_putest_cmd52));
int unifi_putest_cmd52_write(unifi_priv_t *priv, unsigned char *arg)
{
struct unifi_putest_cmd52 cmd52_params;
- CsrUint8 *arg_pos;
+ u8 *arg_pos;
unsigned int cmd_param_size;
CsrResult csrResult;
- CsrUint8 retries;
+ u8 retries;
- arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+ arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1);
if (get_user(cmd_param_size, (int*)arg_pos)) {
unifi_error(priv,
"unifi_putest_cmd52_write: Failed to get the argument\n");
int unifi_putest_gp_read16(unifi_priv_t *priv, unsigned char *arg)
{
struct unifi_putest_gp_rw16 gp_r16_params;
- CsrUint8 *arg_pos;
+ u8 *arg_pos;
unsigned int cmd_param_size;
int r;
CsrResult csrResult;
unsigned char ret_buffer[32];
- CsrUint8 *ret_buffer_pos;
+ u8 *ret_buffer_pos;
- arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+ arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1);
if (get_user(cmd_param_size, (int*)arg_pos)) {
unifi_error(priv,
"unifi_putest_gp_read16: Failed to get the argument\n");
/* Copy the info to the out buffer */
*(unifi_putest_command_t*)ret_buffer = UNIFI_PUTEST_GP_READ16;
- ret_buffer_pos = (CsrUint8*)(((unifi_putest_command_t*)ret_buffer) + 1);
+ ret_buffer_pos = (u8*)(((unifi_putest_command_t*)ret_buffer) + 1);
*(unsigned int*)ret_buffer_pos = sizeof(struct unifi_putest_gp_rw16);
ret_buffer_pos += sizeof(unsigned int);
memcpy(ret_buffer_pos, &gp_r16_params, sizeof(struct unifi_putest_gp_rw16));
int unifi_putest_gp_write16(unifi_priv_t *priv, unsigned char *arg)
{
struct unifi_putest_gp_rw16 gp_w16_params;
- CsrUint8 *arg_pos;
+ u8 *arg_pos;
unsigned int cmd_param_size;
CsrResult csrResult;
- arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+ arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1);
if (get_user(cmd_param_size, (int*)arg_pos)) {
unifi_error(priv,
"unifi_putest_gp_write16: Failed to get the argument\n");
int unifi_putest_cmd52_block_read(unifi_priv_t *priv, unsigned char *arg)
{
struct unifi_putest_block_cmd52_r block_cmd52;
- CsrUint8 *arg_pos;
+ u8 *arg_pos;
unsigned int cmd_param_size;
CsrResult r;
- CsrUint8 *block_local_buffer;
+ u8 *block_local_buffer;
- arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+ arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1);
if (get_user(cmd_param_size, (int*)arg_pos)) {
unifi_error(priv,
"cmd52r_block: Failed to get the argument\n");
CsrResult
-CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data)
+CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, u8 *data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err = 0;
} /* CsrSdioRead8() */
CsrResult
-CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data)
+CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, u8 data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err = 0;
CsrResult
-CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data)
+CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, u8 *data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err = 0;
} /* CsrSdioF0Read8() */
CsrResult
-CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data)
+CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, u8 data)
{
struct sdio_func *func = (struct sdio_func *)function->priv;
int err = 0;
CsrWifiSmeScanResultsGetCfm* cfm = (CsrWifiSmeScanResultsGetCfm*)msg;
int bytesRequired = cfm->scanResultsCount * sizeof(CsrWifiSmeScanResult);
int i;
- CsrUint8* current_buff;
+ u8* current_buff;
CsrWifiSmeScanResult* scanCopy;
if (priv == NULL) {
memcpy(scanCopy, cfm->scanResults, sizeof(CsrWifiSmeScanResult) * cfm->scanResultsCount);
/* Take a Copy of the Info Elements AND update the scan result pointers */
- current_buff = (CsrUint8*)&scanCopy[cfm->scanResultsCount];
+ current_buff = (u8*)&scanCopy[cfm->scanResultsCount];
for (i = 0; i < cfm->scanResultsCount; ++i)
{
CsrWifiSmeScanResult *scan_result = &scanCopy[i];
int client_id;
CSR_SIGNAL unpacked_signal;
- CsrUint8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
+ u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
CsrUint16 packed_siglen;
CsrWifiRouterCtrlHipIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,
packed_siglen,
- (CsrUint8 *)sigbuf,
+ (u8 *)sigbuf,
0, NULL,
0, NULL);
}
struct sk_buff *skb, *newSkb = NULL;
CsrInt8 protection;
int r;
- static const CsrUint8 arp_req[36] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00,
+ static const u8 arp_req[36] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00,
0x08, 0x06, 0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01,
0x00, 0x02, 0x5f, 0x20, 0x2f, 0x02,
0xc0, 0xa8, 0x00, 0x02,
const int queue,
CsrUint16 interfaceTag)
{
- const CsrUint8 broadcast_mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+ const u8 broadcast_mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
unifi_port_config_t *port;
netInterface_priv_t *interfacePriv;
int i;
case CSR_WIFI_ROUTER_CTRL_MODE_AP:
case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
{
- CsrUint8 i;
+ u8 i;
CsrWifiRouterCtrlStaInfo_t *staRecord;
/* Ifscontrolled port is open means, The peer has been added to station record
* so that the protection corresponding to the peer is valid in this req
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiRouterMaPacketSubscribeReq* req = (CsrWifiRouterMaPacketSubscribeReq*)msg;
- CsrUint8 i;
+ u8 i;
CsrResult result;
if (priv == NULL) {
priv->sme_unidata_ind_filters[i].encapsulation = req->encapsulation;
priv->sme_unidata_ind_filters[i].protocol = req->protocol;
- priv->sme_unidata_ind_filters[i].oui[2] = (CsrUint8) (req->oui & 0xFF);
- priv->sme_unidata_ind_filters[i].oui[1] = (CsrUint8) ((req->oui >> 8) & 0xFF);
- priv->sme_unidata_ind_filters[i].oui[0] = (CsrUint8) ((req->oui >> 16) & 0xFF);
+ priv->sme_unidata_ind_filters[i].oui[2] = (u8) (req->oui & 0xFF);
+ priv->sme_unidata_ind_filters[i].oui[1] = (u8) ((req->oui >> 8) & 0xFF);
+ priv->sme_unidata_ind_filters[i].oui[0] = (u8) ((req->oui >> 16) & 0xFF);
result = CSR_RESULT_SUCCESS;
break;
static int
_sys_packet_req(unifi_priv_t *priv, const CSR_SIGNAL *signal,
- CsrUint8 subscriptionHandle,
- CsrUint16 frameLength, CsrUint8 *frame,
+ u8 subscriptionHandle,
+ CsrUint16 frameLength, u8 *frame,
int proto)
{
int r;
CSR_SIGNAL signal;
CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
CsrWifiRouterCtrlPortAction controlPortaction;
- CsrUint8 *daddr, *saddr;
+ u8 *daddr, *saddr;
CsrUint16 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)
{
- CsrUint8 i,j;
+ u8 i,j;
CsrWifiRouterCtrlStaInfo_t *staInfo=NULL;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
unsigned long lock_flags;
{
netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
#ifdef CSR_WIFI_SPLIT_PATCH
- CsrUint8 old_mode = interfacePriv->interfaceMode;
+ u8 old_mode = interfacePriv->interfaceMode;
#endif
unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlModeSetReqHandler: interfacePriv->interfaceMode = %d\n",
interfacePriv->interfaceMode);
/* delete the station record from the station record data base */
static int peer_delete_record(unifi_priv_t *priv, CsrWifiRouterCtrlPeerDelReq *req)
{
- CsrUint8 j;
+ u8 j;
CsrWifiRouterCtrlStaInfo_t *staInfo = NULL;
unifi_port_config_t *controlledPort;
unifi_port_config_t *unControlledPort;
netInterface_priv_t *interfacePriv;
- CsrUint8 ba_session_idx = 0;
+ u8 ba_session_idx = 0;
ba_session_rx_struct *ba_session_rx = NULL;
ba_session_tx_struct *ba_session_tx = NULL;
/* Add the new station to the station record data base */
static int peer_add_new_record(unifi_priv_t *priv,CsrWifiRouterCtrlPeerAddReq *req,CsrUint32 *handle)
{
- CsrUint8 i, powerModeTemp = 0;
+ u8 i, powerModeTemp = 0;
CsrBool freeSlotFound = FALSE;
CsrWifiRouterCtrlStaInfo_t *newRecord = NULL;
netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
newRecord->assignedHandle = i;
/* copy power save mode of all access catagory (Trigger/Delivery/both enabled/disabled) */
- powerModeTemp = (CsrUint8) ((req->staInfo.powersaveMode >> 4) & 0xff);
+ powerModeTemp = (u8) ((req->staInfo.powersaveMode >> 4) & 0xff);
if(!(req->staInfo.powersaveMode & 0x0001))
newRecord->powersaveMode[UNIFI_TRAFFIC_Q_BK]= CSR_WIFI_AC_LEGACY_POWER_SAVE;
newRecord->powersaveMode[UNIFI_TRAFFIC_Q_VO]= ((powerModeTemp & 0xC0)>> 6);
{
- CsrUint8 k;
+ u8 k;
for(k=0; k< MAX_ACCESS_CATOGORY ;k++)
unifi_trace(priv, UDBG2, "peer_add_new_record: WMM : %d ,AC %d, powersaveMode %x \n",
req->staInfo.wmmOrQosEnabled,k,newRecord->powersaveMode[k]);
/* Initialize the mgtFrames & data Pdu list */
{
- CsrUint8 j;
+ u8 j;
INIT_LIST_HEAD(&newRecord->mgtFrames);
for(j = 0; j < MAX_ACCESS_CATOGORY; j++) {
INIT_LIST_HEAD(&newRecord->dataPdu[j]);
{
struct unifi_priv *priv;
CsrWifiRouterCtrlStaInfo_t *sta_record = NULL;
- CsrUint8 i = 0;
+ u8 i = 0;
CsrTime now;
CsrTime inactive_time;
netInterface_priv_t *interfacePriv = (netInterface_priv_t *) data;
unifi_priv_t *priv;
CsrUint16 interfaceTag;
struct list_head send_cfm_list;
- CsrUint8 j;
+ u8 j;
func_enter();
netInterface_priv_t *interfacePriv;
ba_session_rx_struct *ba_session_rx = NULL;
ba_session_tx_struct *ba_session_tx = NULL;
- CsrUint8 ba_session_idx = 0;
+ u8 ba_session_idx = 0;
int i;
if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
netInterface_priv_t *interfacePriv;
ba_session_rx_struct *ba_session_rx = NULL;
ba_session_tx_struct *ba_session_tx = NULL;
- CsrUint8 ba_session_idx = 0;
+ u8 ba_session_idx = 0;
if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
CsrWifiRouterCtrlWapiUnicastTxPktReq *req = (CsrWifiRouterCtrlWapiUnicastTxPktReq*) msg;
netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
bulk_data_param_t bulkdata;
- CsrUint8 macHeaderLengthInBytes = MAC_HEADER_SIZE;
+ u8 macHeaderLengthInBytes = MAC_HEADER_SIZE;
/*KeyID, Reserved, PN, MIC*/
- CsrUint8 appendedCryptoFields = 1 + 1 + 16 + 16;
+ u8 appendedCryptoFields = 1 + 1 + 16 + 16;
CsrResult result;
/* Retrieve the MA PACKET REQ fields from the Signal retained from send_ma_pkt_request() */
CSR_MA_PACKET_REQUEST *storedSignalMAPktReq = &interfacePriv->wapi_unicast_ma_pkt_sig.u.MaPacketRequest;
uf_sme_deinit(unifi_priv_t *priv)
{
int i,j;
- CsrUint8 ba_session_idx;
+ u8 ba_session_idx;
ba_session_rx_struct *ba_session_rx = NULL;
ba_session_tx_struct *ba_session_tx = NULL;
CsrWifiRouterCtrlStaInfo_t *staInfo = NULL;
#include "csr_wifi_sme_lib.h"
void CsrWifiRouterTransportInit(unifi_priv_t *priv);
-void CsrWifiRouterTransportRecv(unifi_priv_t *priv, CsrUint8* buffer, CsrSize bufferLength);
+void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLength);
void CsrWifiRouterTransportDeInit(unifi_priv_t *priv);
#endif /* __LINUX_SME_USERSPACE_H__ */
const char *token, int param_type,
void *dst, int param_max_len)
{
- CsrUint8 int_str[7] = "0";
+ u8 int_str[7] = "0";
CsrUint32 param_str_len;
- CsrUint8 *param_str_begin,*param_str_end;
- CsrUint8 *orig_str = *str_ptr;
+ u8 *param_str_begin,*param_str_end;
+ u8 *orig_str = *str_ptr;
if (!strncmp(*str_ptr, token, strlen(token))) {
strsep(str_ptr, "=,");
int i,j=0;
CsrWifiNmeApAuthPers *pers =
((CsrWifiNmeApAuthPers *)&(ap_config->credentials.nmeAuthType.authTypePersonal));
- CsrUint8 *psk = pers->authPers_credentials.psk.psk;
+ u8 *psk = pers->authPers_credentials.psk.psk;
unifi_trace(priv,UDBG2,"store_ap_config_from_string: security WPA2");
if(ret) {
iwprivsconfwapi(struct net_device *dev, struct iw_request_info *info,
union iwreq_data *wrqu, char *extra)
{
- CsrUint8 enable;
+ u8 enable;
netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
unifi_priv_t *priv = interfacePriv->privPtr;
func_enter();
return -EPERM;
}
- enable = *(CsrUint8*)(extra);
+ enable = *(u8*)(extra);
if (enable) {
priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
unifi_priv_t *priv = interfacePriv->privPtr;
CsrWifiSmeConnectionInfo connectionInfo;
int r = 0;
- CsrUint8 *bssid;
+ u8 *bssid;
func_enter();
*/
void
logging_handler(void *ospriv,
- CsrUint8 *sigdata, CsrUint32 signal_len,
+ u8 *sigdata, CsrUint32 signal_len,
const bulk_data_param_t *bulkdata,
enum udi_log_direction direction)
{
bulkdata.d[0].data_length = 0;
bulkdata.d[1].data_length = 0;
- sme_native_log_event(priv->sme_cli, conf_param, sizeof(CsrUint8),
+ sme_native_log_event(priv->sme_cli, conf_param, sizeof(u8),
&bulkdata, UDI_CONFIG_IND);
#endif /* CSR_SUPPORT_SME */
} /* free_bulkdata_buffers */
static int
-_align_bulk_data_buffers(unifi_priv_t *priv, CsrUint8 *signal,
+_align_bulk_data_buffers(unifi_priv_t *priv, u8 *signal,
bulk_data_param_t *bulkdata)
{
unsigned int i;
ul_send_signal_unpacked(unifi_priv_t *priv, CSR_SIGNAL *sigptr,
bulk_data_param_t *bulkdata)
{
- CsrUint8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
+ u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
CsrUint16 packed_siglen;
CsrResult csrResult;
unsigned long lock_flags;
* Make sure that the signal is updated with the bulk data
* alignment for DMA.
*/
- r = _align_bulk_data_buffers(priv, (CsrUint8*)sigptr, bulkdata);
+ r = _align_bulk_data_buffers(priv, (u8*)sigptr, bulkdata);
if (r) {
return r;
}
int dir);
void logging_handler(void *ospriv,
- CsrUint8 *sigdata, CsrUint32 signal_len,
+ u8 *sigdata, CsrUint32 signal_len,
const bulk_data_param_t *bulkdata,
enum udi_log_direction direction);
* ---------------------------------------------------------------------------
*/
static CsrBool check_routing_pkt_data_ind(unifi_priv_t *priv,
- CsrUint8 *sigdata,
+ u8 *sigdata,
const bulk_data_param_t* bulkdata,
CsrBool *freeBulkData,
netInterface_priv_t *interfacePriv)
{
CsrUint16 frmCtrl, receptionStatus, frmCtrlSubType;
- CsrUint8 *macHdrLocation;
- CsrUint8 interfaceTag;
+ u8 *macHdrLocation;
+ u8 interfaceTag;
CsrBool isDataFrame;
CsrBool isProtocolVerInvalid = FALSE;
CsrBool isDataFrameSubTypeNoData = FALSE;
#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
- static const CsrUint8 wapiProtocolIdSNAPHeader[] = {0x88,0xb4};
- static const CsrUint8 wapiProtocolIdSNAPHeaderOffset = 6;
- CsrUint8 *destAddr;
- CsrUint8 *srcAddr;
+ static const u8 wapiProtocolIdSNAPHeader[] = {0x88,0xb4};
+ static const u8 wapiProtocolIdSNAPHeaderOffset = 6;
+ u8 *destAddr;
+ u8 *srcAddr;
CsrBool isWapiUnicastPkt = FALSE;
#ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
CsrUint16 qosControl;
#endif
- CsrUint8 llcSnapHeaderOffset = 0;
+ u8 llcSnapHeaderOffset = 0;
- destAddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET;
- srcAddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET;
+ destAddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET;
+ srcAddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET;
/*Individual/Group bit - Bit 0 of first byte*/
isWapiUnicastPkt = (!(destAddr[0] & 0x01)) ? TRUE : FALSE;
*freeBulkData = FALSE;
/* Fetch the MAC header location from MA_PKT_IND packet */
- macHdrLocation = (CsrUint8 *) bulkdata->d[0].os_data_ptr;
+ macHdrLocation = (u8 *) bulkdata->d[0].os_data_ptr;
/* Fetch the Frame Control value from MAC header */
frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation);
if (llcSnapHeaderOffset > 0) {
/* QoS data or Data */
unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): SNAP header found & its offset %d\n",llcSnapHeaderOffset);
- if (memcmp((CsrUint8 *)(bulkdata->d[0].os_data_ptr+llcSnapHeaderOffset+wapiProtocolIdSNAPHeaderOffset),
+ if (memcmp((u8 *)(bulkdata->d[0].os_data_ptr+llcSnapHeaderOffset+wapiProtocolIdSNAPHeaderOffset),
wapiProtocolIdSNAPHeader,sizeof(wapiProtocolIdSNAPHeader))) {
unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): This is a data & NOT a WAI protocol packet\n");
if((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2P)&&\
((CSR_WIFI_80211_GET_FRAME_SUBTYPE(macHdrLocation)) == CSR_WIFI_80211_FRAME_SUBTYPE_BEACON)){
- CsrUint8 *pSsid, *pSsidLen;
- static CsrUint8 P2PWildCardSsid[CSR_WIFI_P2P_WILDCARD_SSID_LENGTH] = {'D', 'I', 'R', 'E', 'C', 'T', '-'};
+ u8 *pSsid, *pSsidLen;
+ static u8 P2PWildCardSsid[CSR_WIFI_P2P_WILDCARD_SSID_LENGTH] = {'D', 'I', 'R', 'E', 'C', 'T', '-'};
pSsidLen = macHdrLocation + MAC_HEADER_SIZE + CSR_WIFI_BEACON_FIXED_LENGTH;
pSsid = pSsidLen + 2;
*/
static void
unifi_process_receive_event(void *ospriv,
- CsrUint8 *sigdata, CsrUint32 siglen,
+ u8 *sigdata, CsrUint32 siglen,
const bulk_data_param_t *bulkdata)
{
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
if (signal_id == CSR_MA_PACKET_INDICATION_ID)
{
#define CSR_MA_PACKET_INDICATION_INTERFACETAG_OFFSET 14
- CsrUint8 interfaceTag;
+ u8 interfaceTag;
netInterface_priv_t *interfacePriv;
/* Pull out interface tag from virtual interface identifier */
#ifdef CSR_SUPPORT_SME
if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_IBSS)
{
- CsrUint8 *saddr;
+ u8 *saddr;
/* Fetch the source address from mac header */
- saddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET;
+ saddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET;
unifi_trace(priv, UDBG5,
"Updating sta activity in IBSS interfaceTag %x Src Addr %x:%x:%x:%x:%x:%x\n",
interfaceTag, saddr[0], saddr[1], saddr[2], saddr[3], saddr[4], saddr[5]);
#if (defined(CSR_SUPPORT_SME) && defined(CSR_WIFI_SECURITY_WAPI_ENABLE))
#define CSR_MA_PACKET_INDICATION_RECEPTION_STATUS_OFFSET sizeof(CSR_SIGNAL_PRIMITIVE_HEADER) + 22
netInterface_priv_t *interfacePriv;
- CsrUint8 interfaceTag;
+ u8 interfaceTag;
CsrUint16 receptionStatus = CSR_RX_SUCCESS;
/* Pull out interface tag from virtual interface identifier */
))
{
CSR_SIGNAL signal;
- CsrUint8 *destAddr;
+ u8 *destAddr;
CsrResult res;
CsrUint16 interfaceTag = 0;
CsrBool isMcastPkt = TRUE;
}
/* Check if the type of MPDU and the respective filter status*/
- destAddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET;
+ destAddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET;
isMcastPkt = (destAddr[0] & 0x01) ? TRUE : FALSE;
unifi_trace(priv, UDBG6,
"1.MPDU type: (%s), 2.Multicast filter: (%s), 3. Unicast filter: (%s)\n",
)
{
unifi_trace(priv, UDBG4, "Sending the WAPI MPDU for MIC check\n");
- CsrWifiRouterCtrlWapiRxMicCheckIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, siglen, sigdata, bulkdata->d[0].data_length, (CsrUint8*)bulkdata->d[0].os_data_ptr);
+ CsrWifiRouterCtrlWapiRxMicCheckIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, siglen, sigdata, bulkdata->d[0].data_length, (u8*)bulkdata->d[0].os_data_ptr);
for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
if (bulkdata->d[i].data_length != 0) {
unifi_trace(priv, UDBG4, "rx_wq_handler: RdPtr = %d WritePtr = %d\n",
priv->rxSignalBuffer.readPointer,priv->rxSignalBuffer.writePointer);
if(priv != NULL) {
- CsrUint8 readPointer = priv->rxSignalBuffer.readPointer;
+ u8 readPointer = priv->rxSignalBuffer.readPointer;
while (readPointer != priv->rxSignalBuffer.writePointer)
{
rx_buff_struct_t *buf = &priv->rxSignalBuffer.rx_buff[readPointer];
*/
void
unifi_receive_event(void *ospriv,
- CsrUint8 *sigdata, CsrUint32 siglen,
+ u8 *sigdata, CsrUint32 siglen,
const bulk_data_param_t *bulkdata)
{
#ifdef CSR_WIFI_RX_PATH_SPLIT
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
- CsrUint8 writePointer;
+ u8 writePointer;
int i;
rx_buff_struct_t * rx_buff;
func_enter();
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,
- CSR_PROCESS_ID leSenderProcessId, CsrUint8 *peerMacAddress,
+ CSR_PROCESS_ID leSenderProcessId, u8 *peerMacAddress,
CSR_SIGNAL *signal)
{
CSR_MA_PACKET_REQUEST *req = &signal->u.MaPacketRequest;
netInterface_priv_t *interfacePriv;
- CsrUint8 ba_session_idx = 0;
+ u8 ba_session_idx = 0;
ba_session_tx_struct *ba_session = NULL;
- CsrUint8 *ba_addr = NULL;
+ u8 *ba_addr = NULL;
interfacePriv = priv->interfacePriv[interfaceTag];
CSR_SIGNAL signal;
bulk_data_param_t bulkdata;
int result;
- CsrUint8 toDs, fromDs, macHeaderLengthInBytes = MAC_HEADER_SIZE;
- CsrUint8 *qc;
+ u8 toDs, fromDs, macHeaderLengthInBytes = MAC_HEADER_SIZE;
+ u8 *qc;
CsrUint16 *fc = (CsrUint16*)(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);
/* If order bit set then HT control field is the part of MAC header */
if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
macHeaderLengthInBytes += HT_CONTROL_HEADER_SIZE;
- qc = (CsrUint8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-6));
+ qc = (u8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-6));
} else {
- qc = (CsrUint8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-2));
+ qc = (u8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-2));
}
*qc = eosp ? *qc | (1 << 4) : *qc & (~(1 << 4));
break;
unsigned long lock_flags;
struct list_head *listHead, *list;
struct list_head *placeHolder;
- CsrUint8 i, j,eospFramedeleted=0;
+ u8 i, j,eospFramedeleted=0;
CsrBool thresholdExcedeDueToBroadcast = TRUE;
/* it will be made it interface Specific in the future when multi interfaces are supported ,
right now interface 0 is considered */
unifi_trace(priv, UDBG6, "unifi_reque_ma_packet_request: host_tag = 0x%x\n", host_tag);
staRecord = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,
- (((CsrUint8 *) bulkDataDesc->os_data_ptr) + 4),
+ (((u8 *) bulkDataDesc->os_data_ptr) + 4),
interfaceTag);
if (NULL == staRecord) {
unifi_trace(priv, UDBG5, "unifi_reque_ma_packet_request: Invalid STA record \n");
/* Extract the Packet priority */
if (TRUE == staRecord->wmmOrQosEnabled) {
CsrUint16 qosControl = 0;
- CsrUint8 dataFrameType = 0;
+ u8 dataFrameType = 0;
dataFrameType =((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> 4);
}
#endif
-static void is_all_ac_deliver_enabled_and_moredata(CsrWifiRouterCtrlStaInfo_t *staRecord, CsrUint8 *allDeliveryEnabled, CsrUint8 *dataAvailable)
+static void is_all_ac_deliver_enabled_and_moredata(CsrWifiRouterCtrlStaInfo_t *staRecord, u8 *allDeliveryEnabled, u8 *dataAvailable)
{
- CsrUint8 i;
+ u8 i;
*allDeliveryEnabled = TRUE;
for (i = 0 ;i < MAX_ACCESS_CATOGORY; i++) {
if (!IS_DELIVERY_ENABLED(staRecord->powersaveMode[i])) {
*/
void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, CsrUint16 receiverProcessId)
{
- CsrUint8 handle = CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId);
- CsrUint8 timSetStatus = CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(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);
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;
/* Irrespective of interface the count maintained */
- static CsrUint8 retryCount = 0;
+ static u8 retryCount = 0;
unsigned long lock_flags;
unifi_trace(priv, UDBG3, "entering %s, handle = %x, timSetStatus = %x\n", __FUNCTION__, handle, timSetStatus);
!list_empty(&staRecord->mgtFrames));
} else {
/* Peer is QSTA */
- CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+ u8 allDeliveryEnabled = 0, dataAvailable = 0;
/* Check if all AC's are Delivery Enabled */
is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
/*check for more data in non-delivery enabled queues*/
*
* ---------------------------------------------------------------------------
*/
-void update_tim(unifi_priv_t * priv, CsrUint16 aid, CsrUint8 setTim, CsrUint16 interfaceTag, CsrUint32 handle)
+void update_tim(unifi_priv_t * priv, CsrUint16 aid, u8 setTim, CsrUint16 interfaceTag, CsrUint32 handle)
{
CSR_SIGNAL signal;
CsrInt32 r;
CSR_MLME_SET_TIM_REQUEST *req = &signal.u.MlmeSetTimRequest;
bulk_data_param_t *bulkdata = NULL;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
- CsrUint8 senderIdLsb = 0;
+ u8 senderIdLsb = 0;
CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
CsrUint32 oldTimSetStatus = 0, timSetStatus = 0;
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
list_add(&buffered_pkt->q, &staRecord->mgtFrames);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
- priv->pausedStaHandle[3]=(CsrUint8)(staRecord->assignedHandle);
+ priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
spaceAvail[3] = FALSE;
break;
} else {
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
list_add(&buffered_pkt->q, &staRecord->dataPdu[i]);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
- priv->pausedStaHandle[i]=(CsrUint8)(staRecord->assignedHandle);
+ priv->pausedStaHandle[i]=(u8)(staRecord->assignedHandle);
break;
} else {
if(r){
void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,CsrUint16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm)
{
netInterface_priv_t *interfacePriv;
- CsrUint8 i;
+ u8 i;
CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
interfacePriv = priv->interfacePriv[interfaceTag];
if (inactive_time >= STA_INACTIVE_TIMEOUT_VAL)
{
struct list_head send_cfm_list;
- CsrUint8 j;
+ u8 j;
/* The SME/NME may be waiting for confirmation for requested frames to this station.
* Though this is --VERY UNLIKELY-- in case of station in active mode. But still as a
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,
- CsrUint8 macHeaderLengthInBytes,
- CsrUint8 qosDestination)
+ u8 macHeaderLengthInBytes,
+ u8 qosDestination)
{
CsrUint16 *fc = NULL;
- CsrUint8 direction = 0, toDs, fromDs;
- CsrUint8 *bufPtr = NULL;
- CsrUint8 sa[ETH_ALEN], da[ETH_ALEN];
+ u8 direction = 0, toDs, fromDs;
+ u8 *bufPtr = NULL;
+ u8 sa[ETH_ALEN], da[ETH_ALEN];
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
int headroom;
- CsrUint8 macHeaderBuf[IEEE802_11_DATA_FRAME_MAC_HEADER_SIZE] = {0};
+ u8 macHeaderBuf[IEEE802_11_DATA_FRAME_MAC_HEADER_SIZE] = {0};
unifi_trace(priv, UDBG5, "entering the update_macheader function\n");
unifi_trace(priv, UDBG1, " sufficient headroom not there to push updated mac header \n");
return -1;
}
- bufPtr = (CsrUint8 *) skb_push(skb, macHeaderLengthInBytes);
+ bufPtr = (u8 *) skb_push(skb, macHeaderLengthInBytes);
/* update bulk data os_data_ptr */
bulkdata->d[0].os_data_ptr = skb->data;
} else {
/* pointing to QOS control field */
- CsrUint8 qc;
+ u8 qc;
if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
- qc = *((CsrUint8*)(macHeaderBuf + (macHeaderLengthInBytes - 4 - 2)));
+ qc = *((u8*)(macHeaderBuf + (macHeaderLengthInBytes - 4 - 2)));
} else {
- qc = *((CsrUint8*)(macHeaderBuf + (macHeaderLengthInBytes - 2)));
+ qc = *((u8*)(macHeaderBuf + (macHeaderLengthInBytes - 2)));
}
if ((qc & IEEE802_11_QC_TID_MASK) > 7) {
unifi_trace(priv, UDBG3, " sufficient headroom not there to push updated mac header \n");
return -1;
}
- bufPtr = (CsrUint8 *) skb_push(skb, macHeaderLengthInBytes);
+ bufPtr = (u8 *) skb_push(skb, macHeaderLengthInBytes);
}
break;
default:
unifi_trace(priv, UDBG5, "normal Data packet, NO QOS \n");
if (qosDestination) {
- CsrUint8 qc = 0;
+ u8 qc = 0;
unifi_trace(priv, UDBG3, "destination is QOS station \n");
/* Set Ma-Packet.req UP to UP0 */
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
bulkdata->d[0].data_length = newSkb->len;
- bufPtr = (CsrUint8*)data_ptrs.d[0].os_data_ptr;
+ bufPtr = (u8*)data_ptrs.d[0].os_data_ptr;
/* The old skb will not be used again */
kfree_skb(skb);
} else {
/* skb headroom is sufficient to append Macheader */
- bufPtr = (CsrUint8*)skb_push(skb, macHeaderLengthInBytes);
+ bufPtr = (u8*)skb_push(skb, macHeaderLengthInBytes);
bulkdata->d[0].os_data_ptr = skb->data;
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
bulkdata->d[0].data_length = skb->len;
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
bulkdata->d[0].data_length = newSkb->len;
- bufPtr = (CsrUint8*)data_ptrs.d[0].os_data_ptr;
+ bufPtr = (u8*)data_ptrs.d[0].os_data_ptr;
/* The old skb will not be used again */
kfree_skb(skb);
} else {
/* skb headroom is sufficient to append Macheader */
- bufPtr = (CsrUint8*)skb_push(skb, macHeaderLengthInBytes);
+ bufPtr = (u8*)skb_push(skb, macHeaderLengthInBytes);
bulkdata->d[0].os_data_ptr = skb->data;
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
bulkdata->d[0].data_length = skb->len;
struct ethhdr *ehdr, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
const CSR_SIGNAL *signal,
bulk_data_param_t *bulkdata,
- CsrUint8 macHeaderLengthInBytes)
+ u8 macHeaderLengthInBytes)
{
const CSR_MA_PACKET_INDICATION *ind = &(signal->u.MaPacketIndication);
CsrUint16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0x00ff);
#endif
CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
- CsrUint8 *peerMacAddress,
+ u8 *peerMacAddress,
CSR_CLIENT_TAG hostTag,
CsrUint16 interfaceTag,
CSR_TRANSMISSION_CONTROL transmissionControl,
int result;
#ifdef CSR_SUPPORT_SME
CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
- const CsrUint8 *macHdrLocation = bulkdata->d[0].os_data_ptr;
+ const u8 *macHdrLocation = bulkdata->d[0].os_data_ptr;
CsrWifiPacketType pktType;
int frameType = 0;
CsrBool queuePacketDozing = FALSE;
list = &staRecord->mgtFrames;
requeueOnSamePos = TRUE;
unifi_trace(priv, UDBG1, "(ENOSPC) Sending MgtFrames Failed handle = %d so buffering\n",staRecord->assignedHandle);
- priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+ priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
} else if (result) {
status = CSR_RESULT_FAILURE;
}
unifi_trace(priv, UDBG1, "(ENOSPC) Sending Unicast DataPDU to queue %d Failed so buffering\n",priority_q);
requeueOnSamePos = TRUE;
list = &staRecord->dataPdu[priority_q];
- priv->pausedStaHandle[priority_q]=(CsrUint8)(staRecord->assignedHandle);
+ priv->pausedStaHandle[priority_q]=(u8)(staRecord->assignedHandle);
if(!isRouterBufferEnabled(priv,priority_q)) {
unifi_error(priv,"Buffering Not enabled for queue %d \n",priority_q);
}
}
} else {
/* Check for non delivery enable(i.e trigger enable), all delivery enable & legacy AC for TIM update in firmware */
- CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+ u8 allDeliveryEnabled = 0, dataAvailable = 0;
/* Check if all AC's are Delivery Enabled */
is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
if (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable)
}
#ifdef CSR_SUPPORT_SME
-CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *daddr)
+CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *daddr)
{
CsrInt8 protection = 0;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
}
#endif
#ifdef CSR_SUPPORT_SME
-CsrUint8 send_multicast_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
+u8 send_multicast_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
{
int r;
tx_buffered_packets_t * buffered_pkt = NULL;
CsrBool moreData = FALSE;
- CsrUint8 pduSent =0;
+ u8 pduSent =0;
unsigned long lock_flags;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
CsrUint32 hostTag = 0xffffffff;
return pduSent;
}
#endif
-void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,CsrUint8 *sigdata,
+void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata,
CsrUint32 siglen)
{
#ifdef CSR_SUPPORT_SME
CSR_MA_VIF_AVAILABILITY_INDICATION *ind;
int r;
CsrUint16 interfaceTag;
- CsrUint8 pduSent =0;
+ u8 pduSent =0;
CSR_RESULT_CODE resultCode = CSR_RC_SUCCESS;
netInterface_priv_t *interfacePriv;
*/
void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv,
CsrWifiRouterCtrlStaInfo_t * staInfo,
- CsrUint8 queue,
+ u8 queue,
struct list_head *txList)
{
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
list_add(&buffered_pkt->q,txList);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
- priv->pausedStaHandle[queue]=(CsrUint8)(staInfo->assignedHandle);
+ priv->pausedStaHandle[queue]=(u8)(staInfo->assignedHandle);
break;
} else {
if(r){
void uf_send_buffered_data_from_ac(unifi_priv_t *priv,
CsrWifiRouterCtrlStaInfo_t * staInfo,
- CsrUint8 queue,
+ u8 queue,
struct list_head *txList)
{
tx_buffered_packets_t * buffered_pkt = NULL;
list_add(&buffered_pkt->q,txList);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
if(staInfo != NULL){
- priv->pausedStaHandle[queue]=(CsrUint8)(staInfo->assignedHandle);
+ priv->pausedStaHandle[queue]=(u8)(staInfo->assignedHandle);
}
unifi_trace(priv,UDBG3," uf_send_buffered_data_from_ac: PDU sending failed .. no space for queue %d \n",queue);
} else {
CsrUint16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
CsrUint32 startIndex=0,endIndex=0;
CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
- CsrUint8 queue;
+ u8 queue;
CsrBool moreData = FALSE;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
CsrBool uf_is_more_data_for_non_delivery_ac(CsrWifiRouterCtrlStaInfo_t *staRecord)
{
- CsrUint8 i;
+ u8 i;
for(i=0;i<=3;i++)
{
{
CsrInt8 i;
- CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+ u8 allDeliveryEnabled = 0, dataAvailable = 0;
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
unsigned long lock_flags;
is_all_ac_deliver_enabled_and_moredata(staInfo, &allDeliveryEnabled, &dataAvailable);
if ((allDeliveryEnabled && !dataAvailable)) {
if ((staInfo->timSet != CSR_WIFI_TIM_RESET) || (staInfo->timSet != CSR_WIFI_TIM_RESETTING)) {
- staInfo->updateTimReqQueued = (CsrUint8) CSR_WIFI_TIM_RESET;
+ staInfo->updateTimReqQueued = (u8) CSR_WIFI_TIM_RESET;
unifi_trace(priv, UDBG4, " --uf_handle_uspframes_delivery, UAPSD timset\n");
if (!staInfo->timRequestPendingFlag) {
update_tim(priv, staInfo->aid, 0, interfaceTag, staInfo->assignedHandle);
}
-void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
+void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
{
bulk_data_param_t bulkdata;
CsrResult csrResult;
unifi_net_data_free(priv, &bulkdata.d[0]);
return;
}
- memcpy(peerAddress.a, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+ memcpy(peerAddress.a, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
/* convert priority to queue */
priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
return;
}
-void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8 *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)
{
bulk_data_param_t bulkdata;
CsrResult csrResult;
unifi_net_data_free(priv, &bulkdata.d[0]);
return;
}
- memcpy(peerAddress.a, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+ memcpy(peerAddress.a, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
/* convert priority to queue */
priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
transmissionControl &= ~(CSR_NO_CONFIRM_REQUIRED);
CsrBool uf_check_broadcast_bssid(unifi_priv_t *priv, const bulk_data_param_t *bulkdata)
{
- CsrUint8 *bssid = NULL;
+ u8 *bssid = NULL;
static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
- CsrUint8 toDs, fromDs;
+ u8 toDs, fromDs;
toDs = (((bulkdata->d[0].os_data_ptr)[1]) & 0x01) ? 1 : 0;
fromDs =(((bulkdata->d[0].os_data_ptr)[1]) & 0x02) ? 1 : 0;
else if((toDs == 0) && (fromDs ==0))
{
/* BSSID is Address 3 */
- bssid = (CsrUint8 *) (bulkdata->d[0].os_data_ptr + 4 + (2 * ETH_ALEN));
+ bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4 + (2 * ETH_ALEN));
}
else if(toDs)
{
/* BSSID is Address 1 */
- bssid = (CsrUint8 *) (bulkdata->d[0].os_data_ptr + 4);
+ bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4);
}
else if(fromDs)
{
/* BSSID is Address 2 */
- bssid = (CsrUint8 *) (bulkdata->d[0].os_data_ptr + 4 + ETH_ALEN);
+ bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4 + ETH_ALEN);
}
if (memcmp(broadcast_address.a, bssid, ETH_ALEN)== 0)
CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
- CsrUint8 pmBit,CsrUint16 interfaceTag)
+ u8 pmBit,CsrUint16 interfaceTag)
{
CsrBool moreData = FALSE;
CsrBool powerSaveChanged = FALSE;
}
} else {
- CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+ u8 allDeliveryEnabled = 0, dataAvailable = 0;
unifi_trace(priv, UDBG5, "Qos in AP Mode\n");
/* Check if all AC's are Delivery Enabled */
is_all_ac_deliver_enabled_and_moredata(srcStaInfo, &allDeliveryEnabled, &dataAvailable);
-void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pmBit,CsrUint16 interfaceTag)
+void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,CsrUint16 interfaceTag)
{
CsrWifiRouterCtrlStaInfo_t *staRecord =
CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, sa, interfaceTag);
list_add(&buffered_pkt->q, &staRecord->mgtFrames);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
- priv->pausedStaHandle[3]=(CsrUint8)(staRecord->assignedHandle);
+ priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
} else {
if(r){
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
list_add(&buffered_pkt->q, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
- priv->pausedStaHandle[3]=(CsrUint8)(staRecord->assignedHandle);
+ priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
} else {
if(r){
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
list_add(&buffered_pkt->q, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
- priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+ priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
} else {
if(r){
}
} else {
- CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+ u8 allDeliveryEnabled = 0, dataAvailable = 0;
unifi_trace(priv, UDBG3,"Qos Support station.Processing PS-Poll\n");
/*Send Data From Management Frames*/
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
list_add(&buffered_pkt->q, &staRecord->mgtFrames);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
- priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+ priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
} else {
if(r){
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
list_add(&buffered_pkt->q, &staRecord->dataPdu[i]);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
- priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+ priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
} else {
if(r) {
}
/* generic function to get the station record handler */
CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(unifi_priv_t *priv,
- const CsrUint8 *peerMacAddress,
+ const u8 *peerMacAddress,
CsrUint16 interfaceTag)
{
- CsrUint8 i;
+ u8 i;
netInterface_priv_t *interfacePriv;
unsigned long lock_flags;
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
if (elapsedTime > MAX_INACTIVITY_INTERVAL) {
- memcpy((CsrUint8*)&peerMacAddress, (CsrUint8*)&staInfo->peerMacAddress, sizeof(CsrWifiMacAddress));
+ memcpy((u8*)&peerMacAddress, (u8*)&staInfo->peerMacAddress, sizeof(CsrWifiMacAddress));
/* Indicate inactivity for the station */
unifi_trace(priv, UDBG3, "Station %x:%x:%x:%x:%x:%x inactive since %xus\n sending Inactive Ind\n",
}
/* Function to update activity of a station */
-void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *peerMacAddress)
+void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *peerMacAddress)
{
CsrTime elapsedTime, currentTime; /* Time in microseconds */
CsrTime timeHi; /* Not used - Time in microseconds */
{
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
- CsrUint8 i;
+ u8 i;
int j;
tx_buffered_packets_t * buffered_pkt = NULL;
CsrBool hipslotFree[4] = {TRUE,TRUE,TRUE,TRUE};
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
list_add(&buffered_pkt->q, &staInfo->mgtFrames);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
- priv->pausedStaHandle[3]=(CsrUint8)(staInfo->assignedHandle);
+ priv->pausedStaHandle[3]=(u8)(staInfo->assignedHandle);
hipslotFree[3] = FALSE;
break;
} else {
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
list_add(&buffered_pkt->q, &staInfo->dataPdu[j]);
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
- priv->pausedStaHandle[j]=(CsrUint8)(staInfo->assignedHandle);
+ priv->pausedStaHandle[j]=(u8)(staInfo->assignedHandle);
hipslotFree[j]=FALSE;
break;
} else {
void resume_suspended_uapsd(unifi_priv_t* priv,CsrUint16 interfaceTag)
{
- CsrUint8 startIndex;
+ u8 startIndex;
CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
unsigned long lock_flags;
#define CSR_WIFI_80211_FRAME_SUBTYPE_BEACON 0x8
#define CSR_WIFI_BEACON_FIXED_LENGTH 12
#define CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET 4
-#define CSR_WIFI_80211_FRAME_SUBTYPE_BIT_MASK ((CsrUint8)(0xF << CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET))
+#define CSR_WIFI_80211_FRAME_SUBTYPE_BIT_MASK ((u8)(0xF << CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET))
#define CSR_WIFI_80211_GET_FRAME_SUBTYPE(frameBuffer) \
- ((CsrUint8)(((CsrUint8 *)frameBuffer)[0] & CSR_WIFI_80211_FRAME_SUBTYPE_BIT_MASK) >> CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET)
+ ((u8)(((u8 *)frameBuffer)[0] & CSR_WIFI_80211_FRAME_SUBTYPE_BIT_MASK) >> CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET)
/* For M4 request received via netdev*/
-typedef CsrUint8 CsrWifiPacketType;
+typedef u8 CsrWifiPacketType;
#define CSR_WIFI_UNICAST_PDU ((CsrWifiPacketType) 0x00)
#define CSR_WIFI_MULTICAST_PDU ((CsrWifiPacketType) 0x1)
#define CSR_WIFI_BROADCAST_PDU ((CsrWifiPacketType) 0x2)
} rx_buffered_packets_t;
-typedef CsrUint8 CsrWifiAcPowersaveMode;
+typedef u8 CsrWifiAcPowersaveMode;
#define CSR_WIFI_AC_TRIGGER_ONLY_ENABLED 0x00
#define CSR_WIFI_AC_DELIVERY_ONLY_ENABLE 0X01
#define CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED 0X03
CsrWifiRouterCtrlPeerStatus currentPeerState;
struct list_head dataPdu[MAX_ACCESS_CATOGORY];
struct list_head mgtFrames;
- CsrUint8 spStatus;
- CsrUint8 prevFrmType;
- CsrUint8 prevFrmAccessCatogory;
+ u8 spStatus;
+ u8 prevFrmType;
+ u8 prevFrmAccessCatogory;
CsrBool protection;
CsrUint16 aid;
CsrBool txSuspend;
- CsrUint8 timSet;
+ u8 timSet;
/* Dont change the value of below macro for SET & RESET */
#define CSR_WIFI_TIM_RESET 0
#define CSR_WIFI_TIM_SET 1
#define CSR_WIFI_TIM_SETTING 3
CsrBool timRequestPendingFlag;
- CsrUint8 updateTimReqQueued;
+ u8 updateTimReqQueued;
CsrUint16 noOfPktQueued;
}CsrWifiRouterCtrlStaInfo_t;
CsrWifiSsid ssid;
CsrUint16 channel;
CsrWifiNmeApCredentials credentials;
- CsrUint8 max_connections;
- CsrUint8 if_index;
+ u8 max_connections;
+ u8 if_index;
};
#endif
typedef struct
{
- CsrUint8 *bufptr; /* Signal Primitive */
+ u8 *bufptr; /* Signal Primitive */
bulk_data_param_t data_ptrs; /* Bulk Data pointers */
CsrUint16 sig_len;
}rx_buff_struct_t;
typedef struct
{
- CsrUint8 writePointer; /**< write pointer */
- CsrUint8 readPointer; /**< read pointer */
- CsrUint8 size; /**< size of circular buffer */
+ u8 writePointer; /**< write pointer */
+ u8 readPointer; /**< read pointer */
+ u8 size; /**< size of circular buffer */
rx_buff_struct_t rx_buff[CSR_WIFI_RX_SIGNAL_BUFFER_SIZE]; /**< Element of ciruclar buffer */
} rxCircularBuffer_t;
struct net_device *netdev[CSR_WIFI_NUM_INTERFACES];
struct netInterface_priv *interfacePriv[CSR_WIFI_NUM_INTERFACES];
- CsrUint8 totalInterfaceCount;
+ u8 totalInterfaceCount;
int prev_queue;
#ifdef CSR_SUPPORT_SME
/* lock to protect the tx queues list */
spinlock_t tx_q_lock;
- CsrUint8 allPeerDozing;
- CsrUint8 pausedStaHandle[MAX_ACCESS_CATOGORY];
+ u8 allPeerDozing;
+ u8 pausedStaHandle[MAX_ACCESS_CATOGORY];
/* Max packet the driver can queue, irrespective of interface number */
CsrUint16 noOfPktQueuedInDriver;
#define CSR_WIFI_DRIVER_SUPPORT_FOR_MAX_PKT_QUEUEING 512
/* Array to indicate if a particular Tx queue is paused, this may not be
* required in a multiqueue implementation since we can directly stop kernel
* queues */
- CsrUint8 tx_q_paused_flag[UNIFI_TRAFFIC_Q_MAX];
+ u8 tx_q_paused_flag[UNIFI_TRAFFIC_Q_MAX];
#endif
#ifdef CSR_WIFI_RX_PATH_SPLIT
#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
/*Set if multicast KeyID = 1*/
- CsrUint8 wapi_multicast_filter;
+ u8 wapi_multicast_filter;
/*Set if unicast KeyID = 1*/
- CsrUint8 wapi_unicast_filter;
- CsrUint8 wapi_unicast_queued_pkt_filter;
+ u8 wapi_unicast_filter;
+ u8 wapi_unicast_queued_pkt_filter;
#ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
CsrBool isWapiConnection;
#endif
typedef struct {
CsrUint16 queue_length[4];
- CsrUint8 os_queue_paused;
+ u8 os_queue_paused;
} unifi_OsQosInfo;
ba_session_tx_struct *ba_session_tx[MAX_SUPPORTED_BA_SESSIONS_TX];
ba_session_rx_struct *ba_session_rx[MAX_SUPPORTED_BA_SESSIONS_RX];
frame_desc_struct ba_complete[MAX_BA_WIND_SIZE];
- CsrUint8 ba_complete_index;
- CsrUint8 queueEnabled[UNIFI_NO_OF_TX_QS];
+ u8 ba_complete_index;
+ u8 queueEnabled[UNIFI_NO_OF_TX_QS];
struct work_struct send_m4_ready_task;
#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
struct work_struct send_pkt_to_encrypt;
#endif
struct net_device_stats stats;
- CsrUint8 interfaceMode;
+ u8 interfaceMode;
CsrBool protect;
CsrWifiMacAddress bssid;
/*
unifi_port_config_t uncontrolled_data_port;
/* station record maintenance related data structures */
- CsrUint8 num_stations_joined;
+ u8 num_stations_joined;
CsrWifiRouterCtrlStaInfo_t *(staInfo)[UNIFI_MAX_CONNECTIONS];
struct list_head genericMgtFrames;
struct list_head genericMulticastOrBroadCastFrames;
#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,CsrUint8 pmBit,CsrUint16 interfaceTag);
-void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pmBit,CsrUint16 interfaceTag);
+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);
int uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
struct ethhdr *ehdr, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
const CSR_SIGNAL *signal,
bulk_data_param_t *bulkdata,
- CsrUint8 macHeaderLengthInBytes);
+ u8 macHeaderLengthInBytes);
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);
-void uf_send_buffered_data_from_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, CsrUint8 queue, struct list_head *txList);
-void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, CsrUint8 queue, struct list_head *txList);
+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 CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
-void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
+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);
#endif
-CsrResult uf_process_ma_packet_req(unifi_priv_t *priv, CsrUint8 *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);
-void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,CsrUint8 *sigdata, CsrUint32 siglen);
+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);
+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,
CSR_PRIORITY priority,
bulk_data_param_t *bulkdata,
CsrUint16 interfaceTag,
- const CsrUint8 *daddr,
- const CsrUint8 *saddr,
+ const u8 *daddr,
+ const u8 *saddr,
CsrBool protection);
CSR_PRIORITY
get_packet_priority(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr *ehdr, netInterface_priv_t *interfacePriv);
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,
- CSR_PROCESS_ID leSenderProcessId, CsrUint8 *peerMacAddress,
+ CSR_PROCESS_ID leSenderProcessId, u8 *peerMacAddress,
CSR_SIGNAL *signal);
/* Pack the LSB to include station handle & status of tim set */
#define CSR_WIFI_PACK_SENDER_ID_LSB_FOR_TIM_REQ(handle, timState) ((handle << 2) | timState)
/* get the station record handle from the sender ID */
-#define CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId) (CsrUint8) ((receiverProcessId & 0xff) >> 2)
+#define CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId) (u8) ((receiverProcessId & 0xff) >> 2)
/* get the timSet status from the sender ID */
-#define CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId) (CsrUint8) (receiverProcessId & 0x03)
+#define CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId) (u8) (receiverProcessId & 0x03)
/* 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, CsrUint8 setTim, CsrUint16 interfaceTag, CsrUint32 handle);
+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);
/* Clear the Peer station Record, in case of wifioff/unexpected card removal */
CsrWifiMacAddress macAddress);
#ifdef CSR_SUPPORT_SME
/* Fetch the protection information from interface Mode */
-CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *daddr);
+CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 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 CsrUint8 *peerMacAddress,
+ const u8 *peerMacAddress,
CsrUint16 interfaceTag);
/* Fetch the station record handler from data base for matching handle */
CsrUint32 handle,
CsrUint16 interfaceTag);
-void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *peerMacAddress);
+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);
#endif
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
{
CsrUint16 frmCtrl;
CsrBool unicastPdu = TRUE;
- CsrUint8 *macHdrLocation;
- CsrUint8 *raddr = NULL, *taddr = NULL;
+ u8 *macHdrLocation;
+ u8 *raddr = NULL, *taddr = NULL;
CsrWifiMacAddress peerMacAddress;
/* Check if we need to send CsrWifiRouterCtrlMicFailureInd*/
CSR_MA_PACKET_INDICATION *ind = &unpacked_signal.u.MaPacketIndication;
- macHdrLocation = (CsrUint8 *) bulkdata->d[0].os_data_ptr;
+ macHdrLocation = (u8 *) bulkdata->d[0].os_data_ptr;
/* Fetch the frame control value from mac header */
frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation);
{
if(ind->ReceptionStatus == CSR_RX_SUCCESS)
{
- CsrUint8 pmBit = (frmCtrl & 0x1000)?0x01:0x00;
+ u8 pmBit = (frmCtrl & 0x1000)?0x01:0x00;
CsrUint16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0xff);
CsrWifiRouterCtrlStaInfo_t *srcStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,taddr,interfaceTag);
if((srcStaInfo != NULL) && (uf_check_broadcast_bssid(priv, bulkdata)== FALSE))
}
mlmeCommand.length = signal_len;
- mlmeCommand.data = (CsrUint8*)signal;
+ mlmeCommand.data = (u8*)signal;
dataref1.length = bulkdata->d[0].data_length;
if (dataref1.length > 0) {
- dataref1.data = (CsrUint8 *) bulkdata->d[0].os_data_ptr;
+ dataref1.data = (u8 *) bulkdata->d[0].os_data_ptr;
} else
{
dataref1.data = NULL;
dataref2.length = bulkdata->d[1].data_length;
if (dataref2.length > 0) {
- dataref2.data = (CsrUint8 *) bulkdata->d[1].os_data_ptr;
+ dataref2.data = (u8 *) bulkdata->d[1].os_data_ptr;
} else
{
dataref2.data = NULL;
dhcp_tclas->user_priority = 0;
dhcp_tclas->tcp_ip_cls_fr.cls_fr_type = 1;
dhcp_tclas->tcp_ip_cls_fr.version = 4;
- ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[0] = 0x00;
- ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[1] = 0x44;
- ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[0] = 0x00;
- ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[1] = 0x43;
+ ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[0] = 0x00;
+ ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[1] = 0x44;
+ ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[0] = 0x00;
+ ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[1] = 0x43;
dhcp_tclas->tcp_ip_cls_fr.protocol = 0x11;
dhcp_tclas->tcp_ip_cls_fr.cls_fr_mask = 0x58; //bits: 3,4,6
}
int unifi_cfg_wmm_qos_info(unifi_priv_t *priv, unsigned char *arg)
{
- CsrUint8 wmm_qos_info;
+ u8 wmm_qos_info;
int rc = 0;
- if (get_user(wmm_qos_info, (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1))) {
+ if (get_user(wmm_qos_info, (u8*)(((unifi_cfg_command_t*)arg) + 1))) {
unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
return -EFAULT;
}
int unifi_cfg_wmm_addts(unifi_priv_t *priv, unsigned char *arg)
{
CsrUint32 addts_tid;
- CsrUint8 addts_ie_length;
- CsrUint8 *addts_ie;
- CsrUint8 *addts_params;
+ u8 addts_ie_length;
+ u8 *addts_ie;
+ u8 *addts_params;
CsrWifiSmeDataBlock tspec;
CsrWifiSmeDataBlock tclas;
int rc;
- addts_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+ addts_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
if (get_user(addts_tid, (CsrUint32*)addts_params)) {
unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n");
return -EFAULT;
}
addts_params += sizeof(CsrUint32);
- if (get_user(addts_ie_length, (CsrUint8*)addts_params)) {
+ if (get_user(addts_ie_length, (u8*)addts_params)) {
unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n");
return -EFAULT;
}
return -ENOMEM;
}
- addts_params += sizeof(CsrUint8);
+ addts_params += sizeof(u8);
rc = copy_from_user(addts_ie, addts_params, addts_ie_length);
if (rc) {
unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the addts buffer\n");
int unifi_cfg_wmm_delts(unifi_priv_t *priv, unsigned char *arg)
{
CsrUint32 delts_tid;
- CsrUint8 *delts_params;
+ u8 *delts_params;
CsrWifiSmeDataBlock tspec;
CsrWifiSmeDataBlock tclas;
int rc;
- delts_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+ delts_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
if (get_user(delts_tid, (CsrUint32*)delts_params)) {
unifi_error(priv, "unifi_cfg_wmm_delts: Failed to get the argument\n");
return -EFAULT;
int unifi_cfg_strict_draft_n(unifi_priv_t *priv, unsigned char *arg)
{
CsrBool strict_draft_n;
- CsrUint8 *strict_draft_n_params;
+ u8 *strict_draft_n_params;
int rc;
CsrWifiSmeStaConfig staConfig;
CsrWifiSmeDeviceConfig deviceConfig;
- strict_draft_n_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+ strict_draft_n_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
if (get_user(strict_draft_n, (CsrBool*)strict_draft_n_params)) {
unifi_error(priv, "unifi_cfg_strict_draft_n: Failed to get the argument\n");
return -EFAULT;
int unifi_cfg_enable_okc(unifi_priv_t *priv, unsigned char *arg)
{
CsrBool enable_okc;
- CsrUint8 *enable_okc_params;
+ u8 *enable_okc_params;
int rc;
CsrWifiSmeStaConfig staConfig;
CsrWifiSmeDeviceConfig deviceConfig;
- enable_okc_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+ enable_okc_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
if (get_user(enable_okc, (CsrBool*)enable_okc_params)) {
unifi_error(priv, "unifi_cfg_enable_okc: Failed to get the argument\n");
return -EFAULT;
}
#ifdef CSR_SUPPORT_WEXT_AP
int
- uf_configure_supported_rates(CsrUint8 * supportedRates, CsrUint8 phySupportedBitmap)
+ uf_configure_supported_rates(u8 * supportedRates, u8 phySupportedBitmap)
{
int i=0;
CsrBool b=FALSE, g = FALSE, n = FALSE;
unifi_priv_t *priv = interfacePriv->privPtr;
CsrUint32 pktBulkDataLength;
- CsrUint8 *pktBulkData;
+ u8 *pktBulkData;
unsigned long flags;
if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA) {
pktBulkDataLength = interfacePriv->wapi_unicast_bulk_data.data_length;
if (pktBulkDataLength > 0) {
- pktBulkData = (CsrUint8 *)CsrPmemAlloc(pktBulkDataLength);
+ pktBulkData = (u8 *)CsrPmemAlloc(pktBulkDataLength);
CsrMemSet(pktBulkData, 0, pktBulkDataLength);
} else {
unifi_error(priv, "uf_send_pkt_to_encrypt() : invalid buffer\n");
spin_lock_irqsave(&priv->wapi_lock, flags);
/* Copy over the MA PKT REQ bulk data */
- CsrMemCpy(pktBulkData, (CsrUint8*)interfacePriv->wapi_unicast_bulk_data.os_data_ptr, pktBulkDataLength);
+ CsrMemCpy(pktBulkData, (u8*)interfacePriv->wapi_unicast_bulk_data.os_data_ptr, pktBulkDataLength);
/* Free any bulk data buffers allocated for the WAPI Data pkt */
unifi_net_data_free(priv, &interfacePriv->wapi_unicast_bulk_data);
interfacePriv->wapi_unicast_bulk_data.net_buf_length = 0;
CsrUint16 appHandle;
CsrWifiRouterEncapsulation encapsulation;
CsrUint16 protocol;
- CsrUint8 oui[3];
- CsrUint8 in_use;
+ u8 oui[3];
+ u8 in_use;
} sme_ma_unidata_ind_filter_t;
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_config(unifi_priv_t *priv,CsrWifiSmeApMacConfig *ap_mac_config, CsrWifiNmeApConfig *group_security_config);
-int uf_configure_supported_rates(CsrUint8 * supportedRates, CsrUint8 phySupportedBitmap);
+int uf_configure_supported_rates(u8 * supportedRates, u8 phySupportedBitmap);
#endif
int unifi_translate_scan(struct net_device *dev,
struct iw_request_info *info,
-typedef CsrUint8 unifi_putest_command_t;
+typedef u8 unifi_putest_command_t;
#define UNIFI_PUTEST_START 0
#define UNIFI_PUTEST_STOP 1
typedef struct uf_cfg_ap_config
{
- CsrUint8 phySupportedBitmap;
- CsrUint8 channel;
+ u8 phySupportedBitmap;
+ u8 channel;
CsrUint16 beaconInterval;
- CsrUint8 dtimPeriod;
+ u8 dtimPeriod;
CsrBool wmmEnabled;
- CsrUint8 shortSlotTimeEnabled;
+ u8 shortSlotTimeEnabled;
CsrUint16 groupkeyTimeout;
CsrBool strictGtkRekeyEnabled;
CsrUint16 gmkTimeout;
CsrUint16 responseTimeout;
- CsrUint8 retransLimit;
- CsrUint8 rxStbc;
+ u8 retransLimit;
+ u8 rxStbc;
CsrBool rifsModeAllowed;
- CsrUint8 dualCtsProtection;
- CsrUint8 ctsProtectionType;
+ u8 dualCtsProtection;
+ u8 ctsProtectionType;
CsrUint16 maxListenInterval;
}uf_cfg_ap_config_t;
/* WAPI Key */
typedef struct
{
- CsrUint8 unicastKey;
+ u8 unicastKey;
/* If non zero, then unicast key otherwise group key */
- CsrUint8 keyIndex;
- CsrUint8 keyRsc[16];
- CsrUint8 authenticator;
+ u8 keyIndex;
+ u8 keyRsc[16];
+ u8 authenticator;
/* If non zero, then authenticator otherwise supplicant */
- CsrUint8 address[6];
- CsrUint8 key[32];
+ u8 address[6];
+ u8 key[32];
} unifiio_wapi_key_t;
/* Values describing XAP memory regions captured by the mini-coredump system */
projects / profile / ivi / kernel-adaptation-intel-automotive.git / commitdiff