staging: csr: remove CsrSize typedef

Use size_t 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>

drivers/staging/csr/csr_formatted_io.c

@@ -12,7 +12,7 @@
 #include "csr_formatted_io.h"
 #include "csr_util.h"
 
-s32 CsrSnprintf(char *dest, CsrSize n, const char *fmt, ...)
+s32 CsrSnprintf(char *dest, size_t n, const char *fmt, ...)
 {
     s32 r;
     va_list args;

drivers/staging/csr/csr_formatted_io.h

@@ -16,7 +16,7 @@ extern "C" {
 
 #include "csr_types.h"
 
-s32 CsrSnprintf(char *dest, CsrSize n, const char *fmt, ...);
+s32 CsrSnprintf(char *dest, size_t n, const char *fmt, ...);
 
 #ifdef __cplusplus
 }

drivers/staging/csr/csr_framework_ext.c

@@ -161,7 +161,7 @@ EXPORT_SYMBOL_GPL(CsrThreadSleep);
  *      Allocated memory is zero initialised.
  *
  *----------------------------------------------------------------------------*/
-void *CsrMemCalloc(CsrSize numberOfElements, CsrSize elementSize)
+void *CsrMemCalloc(size_t numberOfElements, size_t elementSize)
 {
     void *buf;
     size_t size;
@@ -189,7 +189,7 @@ void *CsrMemCalloc(CsrSize numberOfElements, CsrSize elementSize)
  *      Allocated memory is not initialised.
  *
  *----------------------------------------------------------------------------*/
-void *CsrMemAlloc(CsrSize size)
+void *CsrMemAlloc(size_t size)
 {
     return kmalloc(size, GFP_KERNEL);
 }
@@ -224,7 +224,7 @@ EXPORT_SYMBOL_GPL(CsrMemFree);
  *      Allocated memory is not initialised.
  *
  *----------------------------------------------------------------------------*/
-void *CsrMemAllocDma(CsrSize size)
+void *CsrMemAllocDma(size_t size)
 {
     return kmalloc(size, GFP_KERNEL | GFP_DMA);
 }

drivers/staging/csr/csr_framework_ext.h

@@ -256,11 +256,11 @@ void CsrThreadSleep(u16 sleepTimeInMs);
  *
  *----------------------------------------------------------------------------*/
 #ifdef CSR_MEM_DEBUG
-void *CsrMemAllocDebug(CsrSize size,
+void *CsrMemAllocDebug(size_t size,
     const char *file, u32 line);
 #define CsrMemAlloc(sz) CsrMemAllocDebug((sz), __FILE__, __LINE__)
 #else
-void *CsrMemAlloc(CsrSize size);
+void *CsrMemAlloc(size_t size);
 #endif
 
 /*----------------------------------------------------------------------------*
@@ -277,11 +277,11 @@ void *CsrMemAlloc(CsrSize size);
  *
  *----------------------------------------------------------------------------*/
 #ifdef CSR_MEM_DEBUG
-void *CsrMemCallocDebug(CsrSize numberOfElements, CsrSize elementSize,
+void *CsrMemCallocDebug(size_t numberOfElements, size_t elementSize,
     const char *file, u32 line);
 #define CsrMemCalloc(cnt, sz) CsrMemAllocDebug((cnt), (sz), __FILE__, __LINE__)
 #else
-void *CsrMemCalloc(CsrSize numberOfElements, CsrSize elementSize);
+void *CsrMemCalloc(size_t numberOfElements, size_t elementSize);
 #endif
 
 /*----------------------------------------------------------------------------*
@@ -310,11 +310,11 @@ void CsrMemFree(void *pointer);
  *
  *----------------------------------------------------------------------------*/
 #ifdef CSR_MEM_DEBUG
-void *CsrMemAllocDmaDebug(CsrSize size,
+void *CsrMemAllocDmaDebug(size_t size,
     const char *file, u32 line);
 #define CsrMemAllocDma(sz) CsrMemAllocDmaDebug((sz), __FILE__, __LINE__)
 #else
-void *CsrMemAllocDma(CsrSize size);
+void *CsrMemAllocDma(size_t size);
 #endif
 
 

drivers/staging/csr/csr_log_text.h

@@ -34,7 +34,7 @@ void CsrLogTextRegister(CsrLogTextTaskId taskId, const char *taskName, u16 subOr
    system as a whole. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_CRITICAL_DISABLE)
 void CsrLogTextCritical(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
-void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
+void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, size_t bufferLength, const void *buffer, const char *formatString, ...);
 #define CSR_LOG_TEXT_CRITICAL(taskId_subOrigin_formatString_varargs) CsrLogTextCritical taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_CRITICAL(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_CRITICAL(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_CRITICAL(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferCritical taskId_subOrigin_length_buffer_formatString_varargs
@@ -50,7 +50,7 @@ void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bu
    causing lack of functionality but not loss of system integrity/stability. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_ERROR_DISABLE)
 void CsrLogTextError(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
-void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
+void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, size_t bufferLength, const void *buffer, const char *formatString, ...);
 #define CSR_LOG_TEXT_ERROR(taskId_subOrigin_formatString_varargs) CsrLogTextError taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_ERROR(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_ERROR(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_ERROR(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferError taskId_subOrigin_length_buffer_formatString_varargs
@@ -67,7 +67,7 @@ void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize buffe
    lead to malfunction of the component. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_WARNING_DISABLE)
 void CsrLogTextWarning(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
-void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
+void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, size_t bufferLength, const void *buffer, const char *formatString, ...);
 #define CSR_LOG_TEXT_WARNING(taskId_subOrigin_formatString_varargs) CsrLogTextWarning taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_WARNING(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_WARNING(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_WARNING(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferWarning taskId_subOrigin_length_buffer_formatString_varargs
@@ -83,7 +83,7 @@ void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize buf
    the more severe conditions are encountered. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_INFO_DISABLE)
 void CsrLogTextInfo(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
-void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
+void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, u16 subOrigin, size_t bufferLength, const void *buffer, const char *formatString, ...);
 #define CSR_LOG_TEXT_INFO(taskId_subOrigin_formatString_varargs) CsrLogTextInfo taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_INFO(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_INFO(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_INFO(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferInfo taskId_subOrigin_length_buffer_formatString_varargs
@@ -98,7 +98,7 @@ void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize buffer
 /* DEBUG: Similar to INFO, but dedicated to events that occur more frequently. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_DEBUG_DISABLE)
 void CsrLogTextDebug(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
-void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
+void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, u16 subOrigin, size_t bufferLength, const void *buffer, const char *formatString, ...);
 #define CSR_LOG_TEXT_DEBUG(taskId_subOrigin_formatString_varargs) CsrLogTextDebug taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_DEBUG(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_DEBUG(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_DEBUG(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferDebug taskId_subOrigin_length_buffer_formatString_varargs

drivers/staging/csr/csr_msgconv.c

@@ -72,7 +72,7 @@ static const CsrMsgConvMsgEntry *find_msg_converter(CsrMsgConvPrimEntry *ptr, u1
 }
 
 static void *deserialize_data(u16 primType,
-    CsrSize length,
+    size_t length,
     u8 *data)
 {
     CsrMsgConvPrimEntry *ptr;
@@ -84,7 +84,7 @@ static void *deserialize_data(u16 primType,
     {
         const CsrMsgConvMsgEntry *cv;
         u16 msgId = 0;
-        CsrSize offset = 0;
+        size_t offset = 0;
         CsrUint16Des(&msgId, data, &offset);
 
         cv = find_msg_converter(ptr, msgId);
@@ -105,10 +105,10 @@ static void *deserialize_data(u16 primType,
     return ret;
 }
 
-static CsrSize sizeof_message(u16 primType, void *msg)
+static size_t sizeof_message(u16 primType, void *msg)
 {
     CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
-    CsrSize ret;
+    size_t ret;
 
     if (ptr)
     {
@@ -166,7 +166,7 @@ static u8 free_message(u16 primType, u8 *data)
 
 static u8 *serialize_message(u16 primType,
     void *msg,
-    CsrSize *length,
+    size_t *length,
     u8 *buffer)
 {
     CsrMsgConvPrimEntry *ptr;
@@ -198,16 +198,16 @@ static u8 *serialize_message(u16 primType,
     return ret;
 }
 
-CsrSize CsrMsgConvSizeof(u16 primType, void *msg)
+size_t CsrMsgConvSizeof(u16 primType, void *msg)
 {
     return sizeof_message(primType, msg);
 }
 
-u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, u16 primType, void *msg)
+u8 *CsrMsgConvSerialize(u8 *buffer, size_t maxBufferOffset, size_t *offset, u16 primType, void *msg)
 {
     if (converter)
     {
-        CsrSize serializedLength;
+        size_t serializedLength;
         u8 *bufSerialized;
         u8 *bufOffset = &buffer[*offset];
         bufSerialized = converter->serialize_message(primType, msg, &serializedLength, bufOffset);

drivers/staging/csr/csr_msgconv.h

@@ -20,10 +20,10 @@
 extern "C" {
 #endif
 
-typedef CsrSize (CsrMsgSizeofFunc)(void *msg);
-typedef u8 *(CsrMsgSerializeFunc)(u8 *buffer, CsrSize *length, void *msg);
+typedef size_t (CsrMsgSizeofFunc)(void *msg);
+typedef u8 *(CsrMsgSerializeFunc)(u8 *buffer, size_t *length, void *msg);
 typedef void (CsrMsgFreeFunc)(void *msg);
-typedef void *(CsrMsgDeserializeFunc)(u8 *buffer, CsrSize length);
+typedef void *(CsrMsgDeserializeFunc)(u8 *buffer, size_t length);
 
 /* Converter entry for one message type */
 typedef struct CsrMsgConvMsgEntry
@@ -50,16 +50,16 @@ typedef struct CsrMsgConvPrimEntry
 typedef struct
 {
     CsrMsgConvPrimEntry *profile_converters;
-    void *(*deserialize_data)(u16 primType, CsrSize length, u8 * data);
+    void *(*deserialize_data)(u16 primType, size_t length, u8 * data);
     u8 (*free_message)(u16 primType, u8 *data);
-    CsrSize (*sizeof_message)(u16 primType, void *msg);
+    size_t (*sizeof_message)(u16 primType, void *msg);
     u8 *(*serialize_message)(u16 primType, void *msg,
-                                   CsrSize * length,
+                                   size_t * length,
                                    u8 * buffer);
 } CsrMsgConvEntry;
 
-CsrSize CsrMsgConvSizeof(u16 primType, void *msg);
-u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, u16 primType, void *msg);
+size_t CsrMsgConvSizeof(u16 primType, void *msg);
+u8 *CsrMsgConvSerialize(u8 *buffer, size_t maxBufferOffset, size_t *offset, u16 primType, void *msg);
 void CsrMsgConvCustomLookupRegister(u16 primType, CsrMsgCustomLookupFunc *lookupFunc);
 void CsrMsgConvInsert(u16 primType, const CsrMsgConvMsgEntry *ce);
 CsrMsgConvPrimEntry *CsrMsgConvFind(u16 primType);
@@ -78,65 +78,65 @@ u32 CsrUtf8StringSerLen(const u8 *str);
 u32 CsrUtf16StringSerLen(const u16 *str);
 
 /* Prototypes for primitive type serializers */
-void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value);
-void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value);
-void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value);
-void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length);
-void CsrCharStringSer(u8 *buffer, CsrSize *offset, const char *value);
-void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const u8 *value);
-void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const u16 *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(u16 *value, u8 *buffer, CsrSize *offset);
-void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset);
-void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length);
-void CsrCharStringDes(char **value, u8 *buffer, CsrSize *offset);
-void CsrUtf8StringDes(u8 **value, u8 *buffer, CsrSize *offset);
-void CsrUtf16StringDes(u16 **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);
-u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventDes(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint8Sizeof(void *msg);
-u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint8Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint16Sizeof(void *msg);
-u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint32Sizeof(void *msg);
-u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint16CsrUint8Sizeof(void *msg);
-u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint16CsrUint16Sizeof(void *msg);
-u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint16CsrUint32Sizeof(void *msg);
-u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint16CsrCharStringSizeof(void *msg);
-u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint32CsrUint16Sizeof(void *msg);
-u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint32CsrCharStringSizeof(void *msg);
-u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, CsrSize length);
+void CsrUint8Ser(u8 *buffer, size_t *offset, u8 value);
+void CsrUint16Ser(u8 *buffer, size_t *offset, u16 value);
+void CsrUint32Ser(u8 *buffer, size_t *offset, u32 value);
+void CsrMemCpySer(u8 *buffer, size_t *offset, const void *value, size_t length);
+void CsrCharStringSer(u8 *buffer, size_t *offset, const char *value);
+void CsrUtf8StringSer(u8 *buffer, size_t *offset, const u8 *value);
+void CsrUtf16StringSer(u8 *buffer, size_t *offset, const u16 *value);
+void CsrVoidPtrSer(u8 *buffer, size_t *offset, void *ptr);
+void CsrSizeSer(u8 *buffer, size_t *offset, size_t value);
+
+void CsrUint8Des(u8 *value, u8 *buffer, size_t *offset);
+void CsrUint16Des(u16 *value, u8 *buffer, size_t *offset);
+void CsrUint32Des(u32 *value, u8 *buffer, size_t *offset);
+void CsrMemCpyDes(void *value, u8 *buffer, size_t *offset, size_t length);
+void CsrCharStringDes(char **value, u8 *buffer, size_t *offset);
+void CsrUtf8StringDes(u8 **value, u8 *buffer, size_t *offset);
+void CsrUtf16StringDes(u16 **value, u8 *buffer, size_t *offset);
+void CsrVoidPtrDes(void **value, u8 *buffer, size_t *offset);
+void CsrSizeDes(size_t *value, u8 *buffer, size_t *offset);
+
+size_t CsrEventSizeof(void *msg);
+u8 *CsrEventSer(u8 *ptr, size_t *len, void *msg);
+void *CsrEventDes(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint8Sizeof(void *msg);
+u8 *CsrEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint8Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint16Sizeof(void *msg);
+u8 *CsrEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint16Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint32Sizeof(void *msg);
+u8 *CsrEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint32Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint16CsrUint8Sizeof(void *msg);
+u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint16CsrUint16Sizeof(void *msg);
+u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint16CsrUint32Sizeof(void *msg);
+u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint16CsrCharStringSizeof(void *msg);
+u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint32CsrUint16Sizeof(void *msg);
+u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint32CsrCharStringSizeof(void *msg);
+u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, size_t length);
 
 #ifdef __cplusplus
 }

drivers/staging/csr/csr_pmem.c

@@ -24,7 +24,7 @@
 #include "csr_panic.h"
 #include "csr_pmem.h"
 
-void *CsrPmemAlloc(CsrSize size)
+void *CsrPmemAlloc(size_t size)
 {
     void *ret;
 

drivers/staging/csr/csr_pmem.h

@@ -38,11 +38,11 @@ extern "C" {
 
 *****************************************************************************/
 #ifdef CSR_PMEM_DEBUG
-void *CsrPmemAllocDebug(CsrSize size,
+void *CsrPmemAllocDebug(size_t size,
     const char *file, u32 line);
 #define CsrPmemAlloc(sz) CsrPmemAllocDebug((sz), __FILE__, __LINE__)
 #else
-void *CsrPmemAlloc(CsrSize size);
+void *CsrPmemAlloc(size_t size);
 #endif
 
 
@@ -108,7 +108,7 @@ typedef u8 CsrPmemDebugAllocType;
 #define CSR_PMEM_DEBUG_TYPE_MEM_CALLOC    3
 #define CSR_PMEM_DEBUG_TYPE_MEM_ALLOC_DMA 4
 
-typedef void (CsrPmemDebugOnAlloc)(void *ptr, void *userptr, CsrSize size, CsrPmemDebugAllocType type, const char* file, u32 line);
+typedef void (CsrPmemDebugOnAlloc)(void *ptr, void *userptr, size_t size, CsrPmemDebugAllocType type, const char* file, u32 line);
 typedef void (CsrPmemDebugOnFree)(void *ptr, void *userptr, CsrPmemDebugAllocType type, const char* file, u32 line);
 
 /*----------------------------------------------------------------------------*
@@ -127,7 +127,7 @@ typedef void (CsrPmemDebugOnFree)(void *ptr, void *userptr, CsrPmemDebugAllocTyp
  *----------------------------------------------------------------------------*/
 void CsrPmemDebugInstallHooks(u8 headSize, u8 endSize, CsrPmemDebugOnAlloc *onAllocCallback, CsrPmemDebugOnFree *onFreeCallback);
 
-void *CsrPmemDebugAlloc(CsrSize size, CsrPmemDebugAllocType type, const char* file, u32 line);
+void *CsrPmemDebugAlloc(size_t size, CsrPmemDebugAllocType type, const char* file, u32 line);
 #define CsrPmemAlloc(size) CsrPmemDebugAlloc(size, CSR_PMEM_DEBUG_TYPE_PMEM_ALLOC, __FILE__, __LINE__)
 
 void CsrPmemDebugFree(void *ptr, CsrPmemDebugAllocType type, const char* file, u32 line);

drivers/staging/csr/csr_serialize_primitive_types.c

@@ -16,14 +16,14 @@
 #include "csr_pmem.h"
 #include "csr_lib.h"
 
-void CsrUint8Des(u8 *value, u8 *buffer, CsrSize *offset)
+void CsrUint8Des(u8 *value, u8 *buffer, size_t *offset)
 {
     *value = buffer[*offset];
     *offset += sizeof(*value);
 }
 EXPORT_SYMBOL_GPL(CsrUint8Des);
 
-void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset)
+void CsrUint16Des(u16 *value, u8 *buffer, size_t *offset)
 {
     *value = (buffer[*offset + 0] << 0) |
              (buffer[*offset + 1] << 8);
@@ -31,7 +31,7 @@ void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset)
 }
 EXPORT_SYMBOL_GPL(CsrUint16Des);
 
-void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset)
+void CsrUint32Des(u32 *value, u8 *buffer, size_t *offset)
 {
     *value = (buffer[*offset + 0] << 0) |
              (buffer[*offset + 1] << 8) |
@@ -41,27 +41,27 @@ void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset)
 }
 EXPORT_SYMBOL_GPL(CsrUint32Des);
 
-void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length)
+void CsrMemCpyDes(void *value, u8 *buffer, size_t *offset, size_t length)
 {
     CsrMemCpy(value, &buffer[*offset], length);
     *offset += length;
 }
 EXPORT_SYMBOL_GPL(CsrMemCpyDes);
 
-void CsrCharStringDes(char **value, u8 *buffer, CsrSize *offset)
+void CsrCharStringDes(char **value, u8 *buffer, size_t *offset)
 {
     *value = CsrStrDup((char *) &buffer[*offset]);
     *offset += CsrStrLen(*value) + 1;
 }
 EXPORT_SYMBOL_GPL(CsrCharStringDes);
 
-void CsrUtf8StringDes(u8 **value, u8 *buffer, CsrSize *offset)
+void CsrUtf8StringDes(u8 **value, u8 *buffer, size_t *offset)
 {
     *value = (u8 *) CsrStrDup((char *) &buffer[*offset]);
     *offset += CsrStrLen((char *) *value) + 1;
 }
 
-void CsrUtf16StringDes(u16 **value, u8 *buffer, CsrSize *offset)
+void CsrUtf16StringDes(u16 **value, u8 *buffer, size_t *offset)
 {
     u32 length, i;
 
@@ -74,7 +74,7 @@ void CsrUtf16StringDes(u16 **value, u8 *buffer, CsrSize *offset)
     }
 }
 
-void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset)
+void CsrSizeDes(size_t *value, u8 *buffer, size_t *offset)
 {
     *value = (buffer[*offset + 0] << 0) |
              (buffer[*offset + 1] << 8) |
@@ -83,19 +83,19 @@ void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset)
     *offset += sizeof(*value);
 }
 
-void CsrVoidPtrDes(void **value, u8 *buffer, CsrSize *offset)
+void CsrVoidPtrDes(void **value, u8 *buffer, size_t *offset)
 {
-    CsrSizeDes((CsrSize *) value, buffer, offset);
+    CsrSizeDes((size_t *) value, buffer, offset);
 }
 
-void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value)
+void CsrUint8Ser(u8 *buffer, size_t *offset, u8 value)
 {
     buffer[*offset] = value;
     *offset += sizeof(value);
 }
 EXPORT_SYMBOL_GPL(CsrUint8Ser);
 
-void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value)
+void CsrUint16Ser(u8 *buffer, size_t *offset, u16 value)
 {
     buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
     buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
@@ -103,7 +103,7 @@ void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value)
 }
 EXPORT_SYMBOL_GPL(CsrUint16Ser);
 
-void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value)
+void CsrUint32Ser(u8 *buffer, size_t *offset, u32 value)
 {
     buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
     buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
@@ -113,14 +113,14 @@ void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value)
 }
 EXPORT_SYMBOL_GPL(CsrUint32Ser);
 
-void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length)
+void CsrMemCpySer(u8 *buffer, size_t *offset, const void *value, size_t length)
 {
     CsrMemCpy(&buffer[*offset], value, length);
     *offset += length;
 }
 EXPORT_SYMBOL_GPL(CsrMemCpySer);
 
-void CsrCharStringSer(u8 *buffer, CsrSize *offset, const char *value)
+void CsrCharStringSer(u8 *buffer, size_t *offset, const char *value)
 {
     if (value)
     {
@@ -134,12 +134,12 @@ void CsrCharStringSer(u8 *buffer, CsrSize *offset, const char *value)
 }
 EXPORT_SYMBOL_GPL(CsrCharStringSer);
 
-void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const u8 *value)
+void CsrUtf8StringSer(u8 *buffer, size_t *offset, const u8 *value)
 {
     CsrCharStringSer(buffer, offset, (char *) value);
 }
 
-void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const u16 *value)
+void CsrUtf16StringSer(u8 *buffer, size_t *offset, const u16 *value)
 {
     if (value)
     {
@@ -159,7 +159,7 @@ void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const u16 *value)
     }
 }
 
-void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value)
+void CsrSizeSer(u8 *buffer, size_t *offset, size_t value)
 {
     buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
     buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
@@ -168,9 +168,9 @@ void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value)
     *offset += sizeof(value);
 }
 
-void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr)
+void CsrVoidPtrSer(u8 *buffer, size_t *offset, void *ptr)
 {
-    CsrSizeSer(buffer, offset, (CsrSize) ptr);
+    CsrSizeSer(buffer, offset, (size_t) ptr);
 }
 
 u32 CsrCharStringSerLen(const char *str)
@@ -210,12 +210,12 @@ u32 CsrUtf16StringSerLen(const u16 *str)
     }
 }
 
-CsrSize CsrEventSizeof(void *msg)
+size_t CsrEventSizeof(void *msg)
 {
     return 2;
 }
 
-u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrEvent *primitive = (CsrEvent *) msg;
     *len = 0;
@@ -223,21 +223,21 @@ u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventDes(u8 *buffer, CsrSize length)
+void *CsrEventDes(u8 *buffer, size_t length)
 {
     CsrEvent *primitive = (CsrEvent *) CsrPmemAlloc(sizeof(CsrEvent));
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
 
     return primitive;
 }
 
-CsrSize CsrEventCsrUint8Sizeof(void *msg)
+size_t CsrEventCsrUint8Sizeof(void *msg)
 {
     return 3;
 }
 
-u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) msg;
     *len = 0;
@@ -246,23 +246,23 @@ u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint8Des(u8 *buffer, CsrSize length)
+void *CsrEventCsrUint8Des(u8 *buffer, size_t length)
 {
     CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrEventCsrUint8));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
     CsrUint8Des(&primitive->value, buffer, &offset);
 
     return primitive;
 }
 
-CsrSize CsrEventCsrUint16Sizeof(void *msg)
+size_t CsrEventCsrUint16Sizeof(void *msg)
 {
     return 4;
 }
 
-u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) msg;
     *len = 0;
@@ -271,23 +271,23 @@ u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint16Des(u8 *buffer, CsrSize length)
+void *CsrEventCsrUint16Des(u8 *buffer, size_t length)
 {
     CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
     CsrUint16Des(&primitive->value, buffer, &offset);
 
     return primitive;
 }
 
-CsrSize CsrEventCsrUint32Sizeof(void *msg)
+size_t CsrEventCsrUint32Sizeof(void *msg)
 {
     return 6;
 }
 
-u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) msg;
     *len = 0;
@@ -296,23 +296,23 @@ u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint32Des(u8 *buffer, CsrSize length)
+void *CsrEventCsrUint32Des(u8 *buffer, size_t length)
 {
     CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrEventCsrUint32));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
     CsrUint32Des(&primitive->value, buffer, &offset);
 
     return primitive;
 }
 
-CsrSize CsrEventCsrUint16CsrUint8Sizeof(void *msg)
+size_t CsrEventCsrUint16CsrUint8Sizeof(void *msg)
 {
     return 5;
 }
 
-u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) msg;
     *len = 0;
@@ -322,11 +322,11 @@ u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, size_t length)
 {
     CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint8));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
     CsrUint16Des(&primitive->value1, buffer, &offset);
     CsrUint8Des(&primitive->value2, buffer, &offset);
@@ -334,12 +334,12 @@ void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length)
     return primitive;
 }
 
-CsrSize CsrEventCsrUint16CsrUint16Sizeof(void *msg)
+size_t CsrEventCsrUint16CsrUint16Sizeof(void *msg)
 {
     return 6;
 }
 
-u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) msg;
     *len = 0;
@@ -349,11 +349,11 @@ u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, size_t length)
 {
     CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint16));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
     CsrUint16Des(&primitive->value1, buffer, &offset);
     CsrUint16Des(&primitive->value2, buffer, &offset);
@@ -361,12 +361,12 @@ void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length)
     return primitive;
 }
 
-CsrSize CsrEventCsrUint16CsrUint32Sizeof(void *msg)
+size_t CsrEventCsrUint16CsrUint32Sizeof(void *msg)
 {
     return 8;
 }
 
-u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) msg;
     *len = 0;
@@ -376,11 +376,11 @@ u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, size_t length)
 {
     CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint32));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
     CsrUint16Des(&primitive->value1, buffer, &offset);
     CsrUint32Des(&primitive->value2, buffer, &offset);
@@ -388,13 +388,13 @@ void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length)
     return primitive;
 }
 
-CsrSize CsrEventCsrUint16CsrCharStringSizeof(void *msg)
+size_t CsrEventCsrUint16CsrCharStringSizeof(void *msg)
 {
     CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
     return 4 + CsrStrLen(primitive->value2) + 1;
 }
 
-u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
     *len = 0;
@@ -404,11 +404,11 @@ u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, size_t length)
 {
     CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrCharString));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
     CsrUint16Des(&primitive->value1, buffer, &offset);
     CsrCharStringDes(&primitive->value2, buffer, &offset);
@@ -416,12 +416,12 @@ void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length)
     return primitive;
 }
 
-CsrSize CsrEventCsrUint32CsrUint16Sizeof(void *msg)
+size_t CsrEventCsrUint32CsrUint16Sizeof(void *msg)
 {
     return 8;
 }
 
-u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) msg;
     *len = 0;
@@ -431,11 +431,11 @@ u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length)
+void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, size_t length)
 {
     CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint32CsrUint16));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
     CsrUint32Des(&primitive->value1, buffer, &offset);
     CsrUint16Des(&primitive->value2, buffer, &offset);
@@ -443,13 +443,13 @@ void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length)
     return primitive;
 }
 
-CsrSize CsrEventCsrUint32CsrCharStringSizeof(void *msg)
+size_t CsrEventCsrUint32CsrCharStringSizeof(void *msg)
 {
     CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
     return 6 + CsrStrLen(primitive->value2) + 1;
 }
 
-u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
     *len = 0;
@@ -459,11 +459,11 @@ u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, CsrSize length)
+void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, size_t length)
 {
     CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) CsrPmemAlloc(sizeof(CsrEventCsrUint32CsrCharString));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
     CsrUint32Des(&primitive->value1, buffer, &offset);
     CsrCharStringDes(&primitive->value2, buffer, &offset);

drivers/staging/csr/csr_types.h

@@ -27,7 +27,6 @@ extern "C" {
 #define TRUE (1)
 
 /* Basic types */
-typedef size_t CsrSize;         /* Return type of sizeof (ISO/IEC 9899:1990 7.1.6) */
 typedef ptrdiff_t CsrPtrdiff;   /* Type of the result of subtracting two pointers (ISO/IEC 9899:1990 7.1.6) */
 typedef uintptr_t CsrUintptr;   /* Unsigned integer large enough to hold any pointer (ISO/IEC 9899:1999 7.18.1.4) */
 typedef ptrdiff_t CsrIntptr;    /* intptr_t is not defined in kernel. Use the equivalent ptrdiff_t. */

drivers/staging/csr/csr_unicode.h

@@ -39,7 +39,7 @@ u16 *CsrUtf16String2XML(u16 *str);
 u16 *CsrXML2Utf16String(u16 *str);
 
 s32 CsrUtf8StrCmp(const u8 *string1, const u8 *string2);
-s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, CsrSize count);
+s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, size_t count);
 u32 CsrUtf8StringLengthInBytes(const u8 *string);
 
 /*******************************************************************************
@@ -66,7 +66,7 @@ u32 CsrUtf8StringLengthInBytes(const u8 *string);
         Returns target
 
 *******************************************************************************/
-u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count);
+u8 *CsrUtf8StrTruncate(u8 *target, size_t count);
 
 /*******************************************************************************
 
@@ -116,7 +116,7 @@ u8 *CsrUtf8StrCpy(u8 *target, const u8 *source);
         Returns target
 
 *******************************************************************************/
-u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count);
+u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, size_t count);
 
 /*******************************************************************************
 
@@ -143,7 +143,7 @@ u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count);
         Returns target
 
 *******************************************************************************/
-u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, CsrSize count);
+u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, size_t count);
 
 /*******************************************************************************
 
@@ -174,8 +174,8 @@ u8 *CsrUtf8StringConcatenateTexts(const u8 *inputText1, const u8 *inputText2, co
  */
 typedef u8 CsrUcs2String;
 
-CsrSize CsrUcs2ByteStrLen(const CsrUcs2String *ucs2String);
-CsrSize CsrConverterUcs2ByteStrLen(const CsrUcs2String *str);
+size_t CsrUcs2ByteStrLen(const CsrUcs2String *ucs2String);
+size_t CsrConverterUcs2ByteStrLen(const CsrUcs2String *str);
 
 u8 *CsrUcs2ByteString2Utf8(const CsrUcs2String *ucs2String);
 CsrUcs2String *CsrUtf82Ucs2ByteString(const u8 *utf8String);

drivers/staging/csr/csr_utf16.c

@@ -564,8 +564,8 @@ static u8 isLegalUtf8(const u8 *codeUnit, u32 length)
 *********************************************************************************/
 u16 *CsrUtf82Utf16String(const u8 *utf8String)
 {
-    CsrSize i, length = 0;
-    CsrSize sourceLength;
+    size_t i, length = 0;
+    size_t sourceLength;
     u16 *dest = NULL;
     u16 *destStart = NULL;
     s8 extraBytes2Read;
@@ -1021,14 +1021,14 @@ s32 CsrUtf8StrCmp(const u8 *string1, const u8 *string2)
     return CsrStrCmp((const char *) string1, (const char *) string2);
 }
 
-s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, CsrSize count)
+s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, size_t count)
 {
     return CsrStrNCmp((const char *) string1, (const char *) string2, count);
 }
 
 u32 CsrUtf8StringLengthInBytes(const u8 *string)
 {
-    CsrSize length = 0;
+    size_t length = 0;
     if (string)
     {
         length = CsrStrLen((const char *) string);
@@ -1041,9 +1041,9 @@ u8 *CsrUtf8StrCpy(u8 *target, const u8 *source)
     return (u8 *) CsrStrCpy((char *) target, (const char *) source);
 }
 
-u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count)
+u8 *CsrUtf8StrTruncate(u8 *target, size_t count)
 {
-    CsrSize lastByte = count - 1;
+    size_t lastByte = count - 1;
 
     target[count] = '\0';
 
@@ -1070,12 +1070,12 @@ u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count)
     return target;
 }
 
-u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count)
+u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, size_t count)
 {
     return (u8 *) CsrStrNCpy((char *) target, (const char *) source, count);
 }
 
-u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, CsrSize count)
+u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, size_t count)
 {
     CsrStrNCpy((char *) target, (const char *) source, count);
     if (target[count - 1] != '\0')

drivers/staging/csr/csr_util.c

@@ -222,31 +222,31 @@ void CsrUInt32ToHex(u32 number, char *str)
 /*  String */
 /*------------------------------------------------------------------*/
 #ifndef CSR_USE_STDC_LIB
-void *CsrMemCpy(void *dest, const void *src, CsrSize count)
+void *CsrMemCpy(void *dest, const void *src, size_t count)
 {
     return memcpy(dest, src, count);
 }
 EXPORT_SYMBOL_GPL(CsrMemCpy);
 
-void *CsrMemSet(void *dest, u8 c, CsrSize count)
+void *CsrMemSet(void *dest, u8 c, size_t count)
 {
     return memset(dest, c, count);
 }
 EXPORT_SYMBOL_GPL(CsrMemSet);
 
-void *CsrMemMove(void *dest, const void *src, CsrSize count)
+void *CsrMemMove(void *dest, const void *src, size_t count)
 {
     return memmove(dest, src, count);
 }
 EXPORT_SYMBOL_GPL(CsrMemMove);
 
-s32 CsrMemCmp(const void *buf1, const void *buf2, CsrSize count)
+s32 CsrMemCmp(const void *buf1, const void *buf2, size_t count)
 {
     return memcmp(buf1, buf2, count);
 }
 EXPORT_SYMBOL_GPL(CsrMemCmp);
 
-void *CsrMemDup(const void *buf1, CsrSize count)
+void *CsrMemDup(const void *buf1, size_t count)
 {
     void *buf2 = NULL;
 
@@ -266,7 +266,7 @@ char *CsrStrCpy(char *dest, const char *src)
     return strcpy(dest, src);
 }
 
-char *CsrStrNCpy(char *dest, const char *src, CsrSize count)
+char *CsrStrNCpy(char *dest, const char *src, size_t count)
 {
     return strncpy(dest, src, count);
 }
@@ -276,7 +276,7 @@ char *CsrStrCat(char *dest, const char *src)
     return strcat(dest, src);
 }
 
-char *CsrStrNCat(char *dest, const char *src, CsrSize count)
+char *CsrStrNCat(char *dest, const char *src, size_t count)
 {
     return strncat(dest, src, count);
 }
@@ -286,7 +286,7 @@ char *CsrStrStr(const char *string1, const char *string2)
     return strstr(string1, string2);
 }
 
-CsrSize CsrStrLen(const char *string)
+size_t CsrStrLen(const char *string)
 {
     return strlen(string);
 }
@@ -297,7 +297,7 @@ s32 CsrStrCmp(const char *string1, const char *string2)
     return strcmp(string1, string2);
 }
 
-s32 CsrStrNCmp(const char *string1, const char *string2, CsrSize count)
+s32 CsrStrNCmp(const char *string1, const char *string2, size_t count)
 {
     return strncmp(string1, string2, count);
 }
@@ -308,7 +308,7 @@ char *CsrStrChr(const char *string, char c)
 }
 #endif
 
-s32 CsrVsnprintf(char *string, CsrSize count, const char *format, va_list args)
+s32 CsrVsnprintf(char *string, size_t count, const char *format, va_list args)
 {
     return vsnprintf(string, count, format, args);
 }
@@ -316,7 +316,7 @@ EXPORT_SYMBOL_GPL(CsrVsnprintf);
 
 char *CsrStrNCpyZero(char *dest,
     const char *src,
-    CsrSize count)
+    size_t count)
 {
     CsrStrNCpy(dest, src, count - 1);
     dest[count - 1] = '\0';
@@ -364,7 +364,7 @@ char *CsrStrDup(const char *string)
 
 int CsrStrNICmp(const char *string1,
     const char *string2,
-    CsrSize count)
+    size_t count)
 {
     u32 index;
     int returnValue = 0;

drivers/staging/csr/csr_util.h

@@ -52,30 +52,30 @@ void CsrUInt32ToHex(u32 number, char *str);
 #define CsrMemSet memset
 #define CsrStrLen strlen
 #else /* !CSR_USE_STDC_LIB */
-void *CsrMemCpy(void *dest, const void *src, CsrSize count);
-void *CsrMemMove(void *dest, const void *src, CsrSize count);
+void *CsrMemCpy(void *dest, const void *src, size_t count);
+void *CsrMemMove(void *dest, const void *src, size_t count);
 char *CsrStrCpy(char *dest, const char *src);
-char *CsrStrNCpy(char *dest, const char *src, CsrSize count);
+char *CsrStrNCpy(char *dest, const char *src, size_t count);
 char *CsrStrCat(char *dest, const char *src);
-char *CsrStrNCat(char *dest, const char *src, CsrSize count);
-s32 CsrMemCmp(const void *buf1, const void *buf2, CsrSize count);
+char *CsrStrNCat(char *dest, const char *src, size_t count);
+s32 CsrMemCmp(const void *buf1, const void *buf2, size_t count);
 s32 CsrStrCmp(const char *string1, const char *string2);
-s32 CsrStrNCmp(const char *string1, const char *string2, CsrSize count);
+s32 CsrStrNCmp(const char *string1, const char *string2, size_t count);
 char *CsrStrChr(const char *string, char c);
 char *CsrStrStr(const char *string1, const char *string2);
-void *CsrMemSet(void *dest, u8 c, CsrSize count);
-CsrSize CsrStrLen(const char *string);
+void *CsrMemSet(void *dest, u8 c, size_t count);
+size_t CsrStrLen(const char *string);
 #endif /* !CSR_USE_STDC_LIB */
-s32 CsrVsnprintf(char *string, CsrSize count, const char *format, va_list args);
+s32 CsrVsnprintf(char *string, size_t count, const char *format, va_list args);
 
 /*------------------------------------------------------------------*/
 /* Non-standard utility functions */
 /*------------------------------------------------------------------*/
-void *CsrMemDup(const void *buf1, CsrSize count);
-int CsrStrNICmp(const char *string1, const char *string2, CsrSize count);
+void *CsrMemDup(const void *buf1, size_t count);
+int CsrStrNICmp(const char *string1, const char *string2, size_t count);
 char *CsrStrDup(const char *string);
 u32 CsrStrToInt(const char *string);
-char *CsrStrNCpyZero(char *dest, const char *src, CsrSize count);
+char *CsrStrNCpyZero(char *dest, const char *src, size_t count);
 
 /*------------------------------------------------------------------*/
 /* Filename */
@@ -86,7 +86,7 @@ const char *CsrGetBaseName(const char *file);
 /* Misc */
 /*------------------------------------------------------------------*/
 u8 CsrIsSpace(u8 c);
-#define CsrOffsetOf(st, m)  ((CsrSize) & ((st *) 0)->m)
+#define CsrOffsetOf(st, m)  ((size_t) & ((st *) 0)->m)
 
 #ifdef __cplusplus
 }

drivers/staging/csr/csr_wifi_msgconv.h

@@ -21,37 +21,37 @@ extern "C" {
 #endif
 
 
-void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, u16 v);
-void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, u32 v);
-void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, u32 v);
+void CsrUint16SerBigEndian(u8 *ptr, size_t *len, u16 v);
+void CsrUint24SerBigEndian(u8 *ptr, size_t *len, u32 v);
+void CsrUint32SerBigEndian(u8 *ptr, size_t *len, u32 v);
 
-void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset);
-void CsrUint24DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset);
-void CsrUint32DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset);
+void CsrUint16DesBigEndian(u16 *v, u8 *buffer, size_t *offset);
+void CsrUint24DesBigEndian(u32 *v, u8 *buffer, size_t *offset);
+void CsrUint32DesBigEndian(u32 *v, u8 *buffer, size_t *offset);
 
-void CsrUint24Ser(u8 *ptr, CsrSize *len, u32 v);
-void CsrUint24Des(u32 *v, u8 *buffer, CsrSize *offset);
+void CsrUint24Ser(u8 *ptr, size_t *len, u32 v);
+void CsrUint24Des(u32 *v, u8 *buffer, size_t *offset);
 
 
-CsrSize CsrWifiEventSizeof(void *msg);
-u8* CsrWifiEventSer(u8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventDes(u8 *buffer, CsrSize length);
+size_t CsrWifiEventSizeof(void *msg);
+u8* CsrWifiEventSer(u8 *ptr, size_t *len, void *msg);
+void* CsrWifiEventDes(u8 *buffer, size_t length);
 
-CsrSize CsrWifiEventCsrUint8Sizeof(void *msg);
-u8* CsrWifiEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint8Des(u8 *buffer, CsrSize length);
+size_t CsrWifiEventCsrUint8Sizeof(void *msg);
+u8* CsrWifiEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg);
+void* CsrWifiEventCsrUint8Des(u8 *buffer, size_t length);
 
-CsrSize CsrWifiEventCsrUint16Sizeof(void *msg);
-u8* CsrWifiEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint16Des(u8 *buffer, CsrSize length);
+size_t CsrWifiEventCsrUint16Sizeof(void *msg);
+u8* CsrWifiEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg);
+void* CsrWifiEventCsrUint16Des(u8 *buffer, size_t length);
 
-CsrSize CsrWifiEventCsrUint32Sizeof(void *msg);
-u8* CsrWifiEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint32Des(u8 *buffer, CsrSize length);
+size_t CsrWifiEventCsrUint32Sizeof(void *msg);
+u8* CsrWifiEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg);
+void* CsrWifiEventCsrUint32Des(u8 *buffer, size_t length);
 
-CsrSize CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg);
-u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length);
+size_t CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg);
+u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg);
+void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, size_t length);
 
 #ifdef __cplusplus
 }

drivers/staging/csr/csr_wifi_nme_ap_serialize.c

@@ -26,10 +26,10 @@ void CsrWifiNmeApPfree(void *ptr)
 }
 
 
-CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg)
+size_t CsrWifiNmeApConfigSetReqSizeof(void *msg)
 {
     CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 104) */
     bufferSize += 2;  /* u16 primitive->apConfig.apGroupkeyTimeout */
@@ -88,7 +88,7 @@ CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *)msg;
     *len = 0;
@@ -149,10 +149,10 @@ u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -226,9 +226,9 @@ void CsrWifiNmeApConfigSetReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg)
+size_t CsrWifiNmeApWpsRegisterReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -239,7 +239,7 @@ CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *)msg;
     *len = 0;
@@ -252,10 +252,10 @@ u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, size_t length)
 {
     CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -268,10 +268,10 @@ void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
+size_t CsrWifiNmeApStartReqSizeof(void *msg)
 {
     CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 112) */
     bufferSize += 2;  /* u16 primitive->interfaceTag */
@@ -355,7 +355,7 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStartReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *)msg;
     *len = 0;
@@ -444,10 +444,10 @@ u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiNmeApStartReqDes(u8 *buffer, size_t length)
 {
     CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -576,9 +576,9 @@ void CsrWifiNmeApStartReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
+size_t CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 51) */
     {
@@ -607,7 +607,7 @@ CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *)msg;
     *len = 0;
@@ -638,10 +638,10 @@ u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, size_t length)
 {
     CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWmmParamUpdateReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -672,9 +672,9 @@ void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg)
+size_t CsrWifiNmeApStaRemoveReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -684,7 +684,7 @@ CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *)msg;
     *len = 0;
@@ -696,10 +696,10 @@ u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, size_t length)
 {
     CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStaRemoveReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -711,9 +711,9 @@ void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg)
+size_t CsrWifiNmeApWpsRegisterCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -722,7 +722,7 @@ CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *)msg;
     *len = 0;
@@ -733,10 +733,10 @@ u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -747,9 +747,9 @@ void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiNmeApStartCfmSizeof(void *msg)
+size_t CsrWifiNmeApStartCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 40) */
     bufferSize += 2;  /* u16 primitive->interfaceTag */
@@ -760,7 +760,7 @@ CsrSize CsrWifiNmeApStartCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStartCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *)msg;
     *len = 0;
@@ -773,10 +773,10 @@ u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiNmeApStartCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -789,9 +789,9 @@ void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiNmeApStopCfmSizeof(void *msg)
+size_t CsrWifiNmeApStopCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -800,7 +800,7 @@ CsrSize CsrWifiNmeApStopCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStopCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *)msg;
     *len = 0;
@@ -811,10 +811,10 @@ u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiNmeApStopCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -825,9 +825,9 @@ void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiNmeApStopIndSizeof(void *msg)
+size_t CsrWifiNmeApStopIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -837,7 +837,7 @@ CsrSize CsrWifiNmeApStopIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStopIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *)msg;
     *len = 0;
@@ -849,10 +849,10 @@ u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiNmeApStopIndDes(u8 *buffer, size_t length)
 {
     CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -864,9 +864,9 @@ void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiNmeApStationIndSizeof(void *msg)
+size_t CsrWifiNmeApStationIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -877,7 +877,7 @@ CsrSize CsrWifiNmeApStationIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStationIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *)msg;
     *len = 0;
@@ -890,10 +890,10 @@ u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApStationIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiNmeApStationIndDes(u8 *buffer, size_t length)
 {
     CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStationInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);

drivers/staging/csr/csr_wifi_nme_ap_serialize.h

@@ -32,19 +32,19 @@ extern "C" {
 
 extern void CsrWifiNmeApPfree(void *ptr);
 
-extern u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeApConfigSetReqSizeof(void *msg);
 extern void CsrWifiNmeApConfigSetReqSerFree(void *msg);
 
-extern u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg);
+extern u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeApWpsRegisterReqSizeof(void *msg);
 #define CsrWifiNmeApWpsRegisterReqSerFree CsrWifiNmeApPfree
 
-extern u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeApStartReqSizeof(void *msg);
+extern u8* CsrWifiNmeApStartReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeApStartReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeApStartReqSizeof(void *msg);
 extern void CsrWifiNmeApStartReqSerFree(void *msg);
 
 #define CsrWifiNmeApStopReqSer CsrWifiEventCsrUint16Ser
@@ -52,14 +52,14 @@ extern void CsrWifiNmeApStartReqSerFree(void *msg);
 #define CsrWifiNmeApStopReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiNmeApStopReqSerFree CsrWifiNmeApPfree
 
-extern u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg);
+extern u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg);
 #define CsrWifiNmeApWmmParamUpdateReqSerFree CsrWifiNmeApPfree
 
-extern u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg);
+extern u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeApStaRemoveReqSizeof(void *msg);
 #define CsrWifiNmeApStaRemoveReqSerFree CsrWifiNmeApPfree
 
 #define CsrWifiNmeApConfigSetCfmSer CsrWifiEventCsrUint16Ser
@@ -67,24 +67,24 @@ extern CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg);
 #define CsrWifiNmeApConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiNmeApConfigSetCfmSerFree CsrWifiNmeApPfree
 
-extern u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg);
+extern u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeApWpsRegisterCfmSizeof(void *msg);
 #define CsrWifiNmeApWpsRegisterCfmSerFree CsrWifiNmeApPfree
 
-extern u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeApStartCfmSizeof(void *msg);
+extern u8* CsrWifiNmeApStartCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeApStartCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeApStartCfmSizeof(void *msg);
 #define CsrWifiNmeApStartCfmSerFree CsrWifiNmeApPfree
 
-extern u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeApStopCfmSizeof(void *msg);
+extern u8* CsrWifiNmeApStopCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeApStopCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeApStopCfmSizeof(void *msg);
 #define CsrWifiNmeApStopCfmSerFree CsrWifiNmeApPfree
 
-extern u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeApStopIndSizeof(void *msg);
+extern u8* CsrWifiNmeApStopIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeApStopIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeApStopIndSizeof(void *msg);
 #define CsrWifiNmeApStopIndSerFree CsrWifiNmeApPfree
 
 #define CsrWifiNmeApWmmParamUpdateCfmSer CsrWifiEventCsrUint16Ser
@@ -92,9 +92,9 @@ extern CsrSize CsrWifiNmeApStopIndSizeof(void *msg);
 #define CsrWifiNmeApWmmParamUpdateCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiNmeApWmmParamUpdateCfmSerFree CsrWifiNmeApPfree
 
-extern u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStationIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeApStationIndSizeof(void *msg);
+extern u8* CsrWifiNmeApStationIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeApStationIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeApStationIndSizeof(void *msg);
 #define CsrWifiNmeApStationIndSerFree CsrWifiNmeApPfree
 
 

drivers/staging/csr/csr_wifi_nme_serialize.h

@@ -29,14 +29,14 @@ extern "C" {
 
 extern void CsrWifiNmePfree(void *ptr);
 
-extern u8* CsrWifiNmeProfileSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeProfileSetReqSizeof(void *msg);
+extern u8* CsrWifiNmeProfileSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeProfileSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeProfileSetReqSizeof(void *msg);
 extern void CsrWifiNmeProfileSetReqSerFree(void *msg);
 
-extern u8* CsrWifiNmeProfileDeleteReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileDeleteReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeProfileDeleteReqSizeof(void *msg);
+extern u8* CsrWifiNmeProfileDeleteReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeProfileDeleteReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeProfileDeleteReqSizeof(void *msg);
 #define CsrWifiNmeProfileDeleteReqSerFree CsrWifiNmePfree
 
 #define CsrWifiNmeProfileDeleteAllReqSer CsrWifiEventSer
@@ -44,19 +44,19 @@ extern CsrSize CsrWifiNmeProfileDeleteReqSizeof(void *msg);
 #define CsrWifiNmeProfileDeleteAllReqSizeof CsrWifiEventSizeof
 #define CsrWifiNmeProfileDeleteAllReqSerFree CsrWifiNmePfree
 
-extern u8* CsrWifiNmeProfileOrderSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileOrderSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeProfileOrderSetReqSizeof(void *msg);
+extern u8* CsrWifiNmeProfileOrderSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeProfileOrderSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeProfileOrderSetReqSizeof(void *msg);
 extern void CsrWifiNmeProfileOrderSetReqSerFree(void *msg);
 
-extern u8* CsrWifiNmeProfileConnectReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileConnectReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeProfileConnectReqSizeof(void *msg);
+extern u8* CsrWifiNmeProfileConnectReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeProfileConnectReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeProfileConnectReqSizeof(void *msg);
 #define CsrWifiNmeProfileConnectReqSerFree CsrWifiNmePfree
 
-extern u8* CsrWifiNmeWpsReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeWpsReqSizeof(void *msg);
+extern u8* CsrWifiNmeWpsReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeWpsReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeWpsReqSizeof(void *msg);
 #define CsrWifiNmeWpsReqSerFree CsrWifiNmePfree
 
 #define CsrWifiNmeWpsCancelReqSer CsrWifiEventCsrUint16Ser
@@ -69,24 +69,24 @@ extern CsrSize CsrWifiNmeWpsReqSizeof(void *msg);
 #define CsrWifiNmeConnectionStatusGetReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiNmeConnectionStatusGetReqSerFree CsrWifiNmePfree
 
-extern u8* CsrWifiNmeSimImsiGetResSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimImsiGetResDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeSimImsiGetResSizeof(void *msg);
+extern u8* CsrWifiNmeSimImsiGetResSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeSimImsiGetResDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeSimImsiGetResSizeof(void *msg);
 extern void CsrWifiNmeSimImsiGetResSerFree(void *msg);
 
-extern u8* CsrWifiNmeSimGsmAuthResSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimGsmAuthResDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeSimGsmAuthResSizeof(void *msg);
+extern u8* CsrWifiNmeSimGsmAuthResSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeSimGsmAuthResDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeSimGsmAuthResSizeof(void *msg);
 extern void CsrWifiNmeSimGsmAuthResSerFree(void *msg);
 
-extern u8* CsrWifiNmeSimUmtsAuthResSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimUmtsAuthResDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeSimUmtsAuthResSizeof(void *msg);
+extern u8* CsrWifiNmeSimUmtsAuthResSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeSimUmtsAuthResDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeSimUmtsAuthResSizeof(void *msg);
 extern void CsrWifiNmeSimUmtsAuthResSerFree(void *msg);
 
-extern u8* CsrWifiNmeWpsConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeWpsConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiNmeWpsConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeWpsConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeWpsConfigSetReqSizeof(void *msg);
 extern void CsrWifiNmeWpsConfigSetReqSerFree(void *msg);
 
 #define CsrWifiNmeEventMaskSetReqSer CsrWifiEventCsrUint32Ser
@@ -109,39 +109,39 @@ extern void CsrWifiNmeWpsConfigSetReqSerFree(void *msg);
 #define CsrWifiNmeProfileDeleteAllCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiNmeProfileDeleteAllCfmSerFree CsrWifiNmePfree
 
-extern u8* CsrWifiNmeProfileOrderSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileOrderSetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeProfileOrderSetCfmSizeof(void *msg);
+extern u8* CsrWifiNmeProfileOrderSetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeProfileOrderSetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeProfileOrderSetCfmSizeof(void *msg);
 #define CsrWifiNmeProfileOrderSetCfmSerFree CsrWifiNmePfree
 
-extern u8* CsrWifiNmeProfileConnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileConnectCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeProfileConnectCfmSizeof(void *msg);
+extern u8* CsrWifiNmeProfileConnectCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeProfileConnectCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeProfileConnectCfmSizeof(void *msg);
 extern void CsrWifiNmeProfileConnectCfmSerFree(void *msg);
 
-extern u8* CsrWifiNmeWpsCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeWpsCfmSizeof(void *msg);
+extern u8* CsrWifiNmeWpsCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeWpsCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeWpsCfmSizeof(void *msg);
 extern void CsrWifiNmeWpsCfmSerFree(void *msg);
 
-extern u8* CsrWifiNmeWpsCancelCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsCancelCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeWpsCancelCfmSizeof(void *msg);
+extern u8* CsrWifiNmeWpsCancelCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeWpsCancelCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeWpsCancelCfmSizeof(void *msg);
 #define CsrWifiNmeWpsCancelCfmSerFree CsrWifiNmePfree
 
-extern u8* CsrWifiNmeConnectionStatusGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeConnectionStatusGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeConnectionStatusGetCfmSizeof(void *msg);
+extern u8* CsrWifiNmeConnectionStatusGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeConnectionStatusGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeConnectionStatusGetCfmSizeof(void *msg);
 #define CsrWifiNmeConnectionStatusGetCfmSerFree CsrWifiNmePfree
 
-extern u8* CsrWifiNmeProfileUpdateIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileUpdateIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeProfileUpdateIndSizeof(void *msg);
+extern u8* CsrWifiNmeProfileUpdateIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeProfileUpdateIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeProfileUpdateIndSizeof(void *msg);
 extern void CsrWifiNmeProfileUpdateIndSerFree(void *msg);
 
-extern u8* CsrWifiNmeProfileDisconnectIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileDisconnectIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeProfileDisconnectIndSizeof(void *msg);
+extern u8* CsrWifiNmeProfileDisconnectIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeProfileDisconnectIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeProfileDisconnectIndSizeof(void *msg);
 extern void CsrWifiNmeProfileDisconnectIndSerFree(void *msg);
 
 #define CsrWifiNmeSimImsiGetIndSer CsrWifiEventSer
@@ -149,14 +149,14 @@ extern void CsrWifiNmeProfileDisconnectIndSerFree(void *msg);
 #define CsrWifiNmeSimImsiGetIndSizeof CsrWifiEventSizeof
 #define CsrWifiNmeSimImsiGetIndSerFree CsrWifiNmePfree
 
-extern u8* CsrWifiNmeSimGsmAuthIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimGsmAuthIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeSimGsmAuthIndSizeof(void *msg);
+extern u8* CsrWifiNmeSimGsmAuthIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeSimGsmAuthIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeSimGsmAuthIndSizeof(void *msg);
 extern void CsrWifiNmeSimGsmAuthIndSerFree(void *msg);
 
-extern u8* CsrWifiNmeSimUmtsAuthIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimUmtsAuthIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiNmeSimUmtsAuthIndSizeof(void *msg);
+extern u8* CsrWifiNmeSimUmtsAuthIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiNmeSimUmtsAuthIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiNmeSimUmtsAuthIndSizeof(void *msg);
 #define CsrWifiNmeSimUmtsAuthIndSerFree CsrWifiNmePfree
 
 #define CsrWifiNmeWpsConfigSetCfmSer CsrWifiEventCsrUint16Ser

drivers/staging/csr/csr_wifi_router_ctrl_serialize.c

@@ -24,9 +24,9 @@ void CsrWifiRouterCtrlPfree(void *ptr)
 }
 
 
-CsrSize CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -36,7 +36,7 @@ CsrSize CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *)msg;
     *len = 0;
@@ -48,10 +48,10 @@ u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlConfigurePowerModeReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -63,10 +63,10 @@ void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlHipReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlHipReqSizeof(void *msg)
 {
     CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
     bufferSize += 2;                            /* u16 primitive->mlmeCommandLength */
@@ -79,7 +79,7 @@ CsrSize CsrWifiRouterCtrlHipReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *)msg;
     *len = 0;
@@ -103,10 +103,10 @@ u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlHipReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -155,9 +155,9 @@ void CsrWifiRouterCtrlHipReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -167,7 +167,7 @@ CsrSize CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *)msg;
     *len = 0;
@@ -179,10 +179,10 @@ u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMediaStatusReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -194,10 +194,10 @@ void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg)
+size_t CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg)
 {
     CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -216,7 +216,7 @@ CsrSize CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *)msg;
     *len = 0;
@@ -237,10 +237,10 @@ u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMulticastAddressRes));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -274,9 +274,9 @@ void CsrWifiRouterCtrlMulticastAddressResSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -289,7 +289,7 @@ CsrSize CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *)msg;
     *len = 0;
@@ -304,10 +304,10 @@ u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPortConfigureReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -322,9 +322,9 @@ void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlQosControlReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlQosControlReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -335,7 +335,7 @@ CsrSize CsrWifiRouterCtrlQosControlReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *)msg;
     *len = 0;
@@ -348,10 +348,10 @@ u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlQosControlReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -364,9 +364,9 @@ void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlSuspendResSizeof(void *msg)
+size_t CsrWifiRouterCtrlSuspendResSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -375,7 +375,7 @@ CsrSize CsrWifiRouterCtrlSuspendResSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *)msg;
     *len = 0;
@@ -386,10 +386,10 @@ u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlSuspendRes));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -400,10 +400,10 @@ void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlTclasAddReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlTclasAddReqSizeof(void *msg)
 {
     CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2;                      /* u16 primitive->interfaceTag */
@@ -414,7 +414,7 @@ CsrSize CsrWifiRouterCtrlTclasAddReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *)msg;
     *len = 0;
@@ -430,10 +430,10 @@ u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasAddReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -462,9 +462,9 @@ void CsrWifiRouterCtrlTclasAddReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg)
+size_t CsrWifiRouterCtrlResumeResSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -473,7 +473,7 @@ CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *)msg;
     *len = 0;
@@ -484,10 +484,10 @@ u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlResumeRes));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -498,10 +498,10 @@ void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlTclasDelReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlTclasDelReqSizeof(void *msg)
 {
     CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2;                      /* u16 primitive->interfaceTag */
@@ -512,7 +512,7 @@ CsrSize CsrWifiRouterCtrlTclasDelReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *)msg;
     *len = 0;
@@ -528,10 +528,10 @@ u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasDelReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -560,9 +560,9 @@ void CsrWifiRouterCtrlTclasDelReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -573,7 +573,7 @@ CsrSize CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *)msg;
     *len = 0;
@@ -586,10 +586,10 @@ u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, CsrSize *len, void *ms
 }
 
 
-void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficClassificationReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -602,9 +602,9 @@ void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 24) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -619,7 +619,7 @@ CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *)msg;
     *len = 0;
@@ -636,10 +636,10 @@ u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficConfigReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -656,10 +656,10 @@ void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlWifiOnReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlWifiOnReqSizeof(void *msg)
 {
     CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2;                     /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -669,7 +669,7 @@ CsrSize CsrWifiRouterCtrlWifiOnReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *)msg;
     *len = 0;
@@ -684,10 +684,10 @@ u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -715,10 +715,10 @@ void CsrWifiRouterCtrlWifiOnReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg)
+size_t CsrWifiRouterCtrlWifiOnResSizeof(void *msg)
 {
     CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 30) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -739,7 +739,7 @@ CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *)msg;
     *len = 0;
@@ -762,10 +762,10 @@ u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnRes));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -796,9 +796,9 @@ void CsrWifiRouterCtrlWifiOnResSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -807,7 +807,7 @@ CsrSize CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *)msg;
     *len = 0;
@@ -818,10 +818,10 @@ u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4TransmitReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -832,9 +832,9 @@ void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlModeSetReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlModeSetReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -847,7 +847,7 @@ CsrSize CsrWifiRouterCtrlModeSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *)msg;
     *len = 0;
@@ -862,10 +862,10 @@ u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlModeSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -880,9 +880,9 @@ void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlPeerAddReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlPeerAddReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -897,7 +897,7 @@ CsrSize CsrWifiRouterCtrlPeerAddReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *)msg;
     *len = 0;
@@ -914,10 +914,10 @@ u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerAddReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -934,9 +934,9 @@ void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlPeerDelReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlPeerDelReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -946,7 +946,7 @@ CsrSize CsrWifiRouterCtrlPeerDelReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *)msg;
     *len = 0;
@@ -958,10 +958,10 @@ u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerDelReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -973,9 +973,9 @@ void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -986,7 +986,7 @@ CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *)msg;
     *len = 0;
@@ -999,10 +999,10 @@ u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerUpdateReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1015,9 +1015,9 @@ void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -1032,7 +1032,7 @@ CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *)msg;
     *len = 0;
@@ -1049,10 +1049,10 @@ u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckEnableReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1069,9 +1069,9 @@ void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -1083,7 +1083,7 @@ CsrSize CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *)msg;
     *len = 0;
@@ -1097,10 +1097,10 @@ u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckDisableReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1114,10 +1114,10 @@ void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg)
 {
     CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2;                       /* u16 primitive->interfaceTag */
@@ -1129,7 +1129,7 @@ CsrSize CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *)msg;
     *len = 0;
@@ -1149,10 +1149,10 @@ u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiRxPktReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1191,10 +1191,10 @@ void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg)
+size_t CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg)
 {
     CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2;                     /* u16 primitive->interfaceTag */
@@ -1204,7 +1204,7 @@ CsrSize CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *)msg;
     *len = 0;
@@ -1219,10 +1219,10 @@ u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxPktReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1250,10 +1250,10 @@ void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlHipIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlHipIndSizeof(void *msg)
 {
     CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
     bufferSize += 2;                            /* u16 primitive->mlmeCommandLength */
@@ -1266,7 +1266,7 @@ CsrSize CsrWifiRouterCtrlHipIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *)msg;
     *len = 0;
@@ -1290,10 +1290,10 @@ u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlHipInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1342,10 +1342,10 @@ void CsrWifiRouterCtrlHipIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg)
 {
     CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1363,7 +1363,7 @@ CsrSize CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *)msg;
     *len = 0;
@@ -1383,10 +1383,10 @@ u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMulticastAddressInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1419,9 +1419,9 @@ void CsrWifiRouterCtrlMulticastAddressIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1432,7 +1432,7 @@ CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *)msg;
     *len = 0;
@@ -1445,10 +1445,10 @@ u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPortConfigureCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1461,9 +1461,9 @@ void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlSuspendIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlSuspendIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1473,7 +1473,7 @@ CsrSize CsrWifiRouterCtrlSuspendIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *)msg;
     *len = 0;
@@ -1485,10 +1485,10 @@ u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlSuspendInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1500,9 +1500,9 @@ void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1512,7 +1512,7 @@ CsrSize CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *)msg;
     *len = 0;
@@ -1524,10 +1524,10 @@ u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasAddCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1539,9 +1539,9 @@ void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1550,7 +1550,7 @@ CsrSize CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *)msg;
     *len = 0;
@@ -1561,10 +1561,10 @@ u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioDeinitialiseCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1575,9 +1575,9 @@ void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 39) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1594,7 +1594,7 @@ CsrSize CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *)msg;
     *len = 0;
@@ -1613,10 +1613,10 @@ u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioInitialiseCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1643,9 +1643,9 @@ void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1655,7 +1655,7 @@ CsrSize CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *)msg;
     *len = 0;
@@ -1667,10 +1667,10 @@ u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasDelCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1682,9 +1682,9 @@ void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1696,7 +1696,7 @@ CsrSize CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *)msg;
     *len = 0;
@@ -1710,10 +1710,10 @@ u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficProtocolInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1727,9 +1727,9 @@ void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 38) */
     bufferSize += 2;  /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1744,7 +1744,7 @@ CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *)msg;
     *len = 0;
@@ -1761,10 +1761,10 @@ u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficSampleInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1781,10 +1781,10 @@ void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlWifiOnIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlWifiOnIndSizeof(void *msg)
 {
     CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 27) */
     bufferSize += 2;                                                                                    /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1799,7 +1799,7 @@ CsrSize CsrWifiRouterCtrlWifiOnIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *)msg;
     *len = 0;
@@ -1816,10 +1816,10 @@ u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1844,9 +1844,9 @@ void CsrWifiRouterCtrlWifiOnIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1855,7 +1855,7 @@ CsrSize CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *)msg;
     *len = 0;
@@ -1866,10 +1866,10 @@ u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1880,9 +1880,9 @@ void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1892,7 +1892,7 @@ CsrSize CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *)msg;
     *len = 0;
@@ -1904,10 +1904,10 @@ u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4ReadyToSendInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1919,9 +1919,9 @@ void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1932,7 +1932,7 @@ CsrSize CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *)msg;
     *len = 0;
@@ -1945,10 +1945,10 @@ u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4TransmittedInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1961,9 +1961,9 @@ void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlMicFailureIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlMicFailureIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -1974,7 +1974,7 @@ CsrSize CsrWifiRouterCtrlMicFailureIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *)msg;
     *len = 0;
@@ -1987,10 +1987,10 @@ u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMicFailureInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2003,9 +2003,9 @@ void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlConnectedIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlConnectedIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2016,7 +2016,7 @@ CsrSize CsrWifiRouterCtrlConnectedIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *)msg;
     *len = 0;
@@ -2029,10 +2029,10 @@ u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlConnectedInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2045,9 +2045,9 @@ void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 19) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2059,7 +2059,7 @@ CsrSize CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *)msg;
     *len = 0;
@@ -2073,10 +2073,10 @@ u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerAddCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2090,9 +2090,9 @@ void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2102,7 +2102,7 @@ CsrSize CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *)msg;
     *len = 0;
@@ -2114,10 +2114,10 @@ u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerDelCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2129,9 +2129,9 @@ void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2141,7 +2141,7 @@ CsrSize CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *)msg;
     *len = 0;
@@ -2153,10 +2153,10 @@ u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlUnexpectedFrameInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2168,9 +2168,9 @@ void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2180,7 +2180,7 @@ CsrSize CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *)msg;
     *len = 0;
@@ -2192,10 +2192,10 @@ u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerUpdateCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2207,9 +2207,9 @@ void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2219,7 +2219,7 @@ CsrSize CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *)msg;
     *len = 0;
@@ -2231,10 +2231,10 @@ u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlCapabilitiesCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2246,9 +2246,9 @@ void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2258,7 +2258,7 @@ CsrSize CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *)msg;
     *len = 0;
@@ -2270,10 +2270,10 @@ u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckEnableCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2285,9 +2285,9 @@ void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2297,7 +2297,7 @@ CsrSize CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *)msg;
     *len = 0;
@@ -2309,10 +2309,10 @@ u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckDisableCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2324,9 +2324,9 @@ void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2338,7 +2338,7 @@ CsrSize CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *)msg;
     *len = 0;
@@ -2352,10 +2352,10 @@ u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckErrorInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2369,9 +2369,9 @@ void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2381,7 +2381,7 @@ CsrSize CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *)msg;
     *len = 0;
@@ -2393,10 +2393,10 @@ u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlStaInactiveInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2408,10 +2408,10 @@ void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg)
 {
     CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2;                       /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2424,7 +2424,7 @@ CsrSize CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *)msg;
     *len = 0;
@@ -2445,10 +2445,10 @@ u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiRxMicCheckInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2488,9 +2488,9 @@ void CsrWifiRouterCtrlWapiRxMicCheckIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterCtrlModeSetCfmSizeof(void *msg)
+size_t CsrWifiRouterCtrlModeSetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2501,7 +2501,7 @@ CsrSize CsrWifiRouterCtrlModeSetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *)msg;
     *len = 0;
@@ -2514,10 +2514,10 @@ u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlModeSetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2530,10 +2530,10 @@ void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg)
+size_t CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg)
 {
     CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2;                     /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
@@ -2544,7 +2544,7 @@ CsrSize CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *)msg;
     *len = 0;
@@ -2560,10 +2560,10 @@ u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, CsrSize *len, void *msg
 }
 
 
-void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxEncryptInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);

drivers/staging/csr/csr_wifi_router_ctrl_serialize.h

@@ -25,49 +25,49 @@ extern "C" {
 
 extern void CsrWifiRouterCtrlPfree(void *ptr);
 
-extern u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg);
 #define CsrWifiRouterCtrlConfigurePowerModeReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlHipReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlHipReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlHipReqSerFree(void *msg);
 
-extern u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg);
 #define CsrWifiRouterCtrlMediaStatusReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg);
 extern void CsrWifiRouterCtrlMulticastAddressResSerFree(void *msg);
 
-extern u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg);
 #define CsrWifiRouterCtrlPortConfigureReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlQosControlReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlQosControlReqSizeof(void *msg);
 #define CsrWifiRouterCtrlQosControlReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlSuspendResSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlSuspendResSizeof(void *msg);
 #define CsrWifiRouterCtrlSuspendResSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlTclasAddReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlTclasAddReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlTclasAddReqSerFree(void *msg);
 
-extern u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlResumeResSizeof(void *msg);
 #define CsrWifiRouterCtrlResumeResSerFree CsrWifiRouterCtrlPfree
 
 #define CsrWifiRouterCtrlRawSdioDeinitialiseReqSer CsrWifiEventCsrUint16Ser
@@ -80,19 +80,19 @@ extern CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg);
 #define CsrWifiRouterCtrlRawSdioInitialiseReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiRouterCtrlRawSdioInitialiseReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlTclasDelReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlTclasDelReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlTclasDelReqSerFree(void *msg);
 
-extern u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg);
 #define CsrWifiRouterCtrlTrafficClassificationReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg);
 #define CsrWifiRouterCtrlTrafficConfigReqSerFree CsrWifiRouterCtrlPfree
 
 #define CsrWifiRouterCtrlWifiOffReqSer CsrWifiEventCsrUint16Ser
@@ -105,39 +105,39 @@ extern CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg);
 #define CsrWifiRouterCtrlWifiOffResSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiRouterCtrlWifiOffResSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlWifiOnReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlWifiOnReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlWifiOnReqSerFree(void *msg);
 
-extern u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlWifiOnResSizeof(void *msg);
 extern void CsrWifiRouterCtrlWifiOnResSerFree(void *msg);
 
-extern u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg);
 #define CsrWifiRouterCtrlM4TransmitReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlModeSetReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlModeSetReqSizeof(void *msg);
 #define CsrWifiRouterCtrlModeSetReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlPeerAddReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlPeerAddReqSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerAddReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlPeerDelReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlPeerDelReqSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerDelReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerUpdateReqSerFree CsrWifiRouterCtrlPfree
 
 #define CsrWifiRouterCtrlCapabilitiesReqSer CsrWifiEventCsrUint16Ser
@@ -145,19 +145,19 @@ extern CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg);
 #define CsrWifiRouterCtrlCapabilitiesReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiRouterCtrlCapabilitiesReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg);
 #define CsrWifiRouterCtrlBlockAckEnableReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg);
 #define CsrWifiRouterCtrlBlockAckDisableReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *msg);
 
 #define CsrWifiRouterCtrlWapiMulticastFilterReqSer CsrWifiEventCsrUint16CsrUint8Ser
@@ -170,9 +170,9 @@ extern void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *msg);
 #define CsrWifiRouterCtrlWapiUnicastFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
 #define CsrWifiRouterCtrlWapiUnicastFilterReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *msg);
 
 #define CsrWifiRouterCtrlWapiFilterReqSer CsrWifiEventCsrUint16CsrUint8Ser
@@ -180,19 +180,19 @@ extern void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *msg);
 #define CsrWifiRouterCtrlWapiFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
 #define CsrWifiRouterCtrlWapiFilterReqSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlHipIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlHipIndSizeof(void *msg);
 extern void CsrWifiRouterCtrlHipIndSerFree(void *msg);
 
-extern u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg);
 extern void CsrWifiRouterCtrlMulticastAddressIndSerFree(void *msg);
 
-extern u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlPortConfigureCfmSerFree CsrWifiRouterCtrlPfree
 
 #define CsrWifiRouterCtrlResumeIndSer CsrWifiEventCsrUint16CsrUint8Ser
@@ -200,39 +200,39 @@ extern CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlResumeIndSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
 #define CsrWifiRouterCtrlResumeIndSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlSuspendIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlSuspendIndSizeof(void *msg);
 #define CsrWifiRouterCtrlSuspendIndSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlTclasAddCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlRawSdioDeinitialiseCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlRawSdioInitialiseCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlTclasDelCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg);
 #define CsrWifiRouterCtrlTrafficProtocolIndSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg);
 #define CsrWifiRouterCtrlTrafficSampleIndSerFree CsrWifiRouterCtrlPfree
 
 #define CsrWifiRouterCtrlWifiOffIndSer CsrWifiEventCsrUint16CsrUint8Ser
@@ -245,94 +245,94 @@ extern CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg);
 #define CsrWifiRouterCtrlWifiOffCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiRouterCtrlWifiOffCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlWifiOnIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlWifiOnIndSizeof(void *msg);
 extern void CsrWifiRouterCtrlWifiOnIndSerFree(void *msg);
 
-extern u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlWifiOnCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg);
 #define CsrWifiRouterCtrlM4ReadyToSendIndSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg);
 #define CsrWifiRouterCtrlM4TransmittedIndSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlMicFailureIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlMicFailureIndSizeof(void *msg);
 #define CsrWifiRouterCtrlMicFailureIndSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlConnectedIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlConnectedIndSizeof(void *msg);
 #define CsrWifiRouterCtrlConnectedIndSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerAddCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerDelCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg);
 #define CsrWifiRouterCtrlUnexpectedFrameIndSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerUpdateCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlCapabilitiesCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlBlockAckEnableCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlBlockAckDisableCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg);
 #define CsrWifiRouterCtrlBlockAckErrorIndSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg);
 #define CsrWifiRouterCtrlStaInactiveIndSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg);
 extern void CsrWifiRouterCtrlWapiRxMicCheckIndSerFree(void *msg);
 
-extern u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlModeSetCfmSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlModeSetCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlModeSetCfmSerFree CsrWifiRouterCtrlPfree
 
-extern u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg);
+extern u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg);
 extern void CsrWifiRouterCtrlWapiUnicastTxEncryptIndSerFree(void *msg);
 
 

drivers/staging/csr/csr_wifi_router_serialize.c

@@ -24,9 +24,9 @@ void CsrWifiRouterPfree(void *ptr)
 }
 
 
-CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg)
+size_t CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -37,7 +37,7 @@ CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *)msg;
     *len = 0;
@@ -50,10 +50,10 @@ u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -66,10 +66,10 @@ void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg)
+size_t CsrWifiRouterMaPacketReqSizeof(void *msg)
 {
     CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 20) */
     bufferSize += 2;                      /* u16 primitive->interfaceTag */
@@ -84,7 +84,7 @@ CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *)msg;
     *len = 0;
@@ -104,10 +104,10 @@ u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterMaPacketReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -141,9 +141,9 @@ void CsrWifiRouterMaPacketReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiRouterMaPacketResSizeof(void *msg)
+size_t CsrWifiRouterMaPacketResSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -153,7 +153,7 @@ CsrSize CsrWifiRouterMaPacketResSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketResSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *)msg;
     *len = 0;
@@ -165,10 +165,10 @@ u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketResDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketRes));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -180,9 +180,9 @@ void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg)
+size_t CsrWifiRouterMaPacketCancelReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -193,7 +193,7 @@ CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *)msg;
     *len = 0;
@@ -206,10 +206,10 @@ u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCancelReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -222,9 +222,9 @@ void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg)
+size_t CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -235,7 +235,7 @@ CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *)msg;
     *len = 0;
@@ -248,10 +248,10 @@ u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -264,9 +264,9 @@ void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg)
+size_t CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -275,7 +275,7 @@ CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *)msg;
     *len = 0;
@@ -286,10 +286,10 @@ u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketUnsubscribeCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -300,9 +300,9 @@ void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg)
+size_t CsrWifiRouterMaPacketCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -313,7 +313,7 @@ CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *)msg;
     *len = 0;
@@ -326,10 +326,10 @@ u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -342,10 +342,10 @@ void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg)
+size_t CsrWifiRouterMaPacketIndSizeof(void *msg)
 {
     CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
     bufferSize += 2;                      /* u16 primitive->interfaceTag */
@@ -361,7 +361,7 @@ CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *)msg;
     *len = 0;
@@ -382,10 +382,10 @@ u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterMaPacketIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketIndDes(u8 *buffer, size_t length)
 {
     CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);

drivers/staging/csr/csr_wifi_router_serialize.h

@@ -25,9 +25,9 @@ extern "C" {
 
 extern void CsrWifiRouterPfree(void *ptr);
 
-extern u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg);
+extern u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg);
 #define CsrWifiRouterMaPacketSubscribeReqSerFree CsrWifiRouterPfree
 
 #define CsrWifiRouterMaPacketUnsubscribeReqSer CsrWifiEventCsrUint16CsrUint8Ser
@@ -35,39 +35,39 @@ extern CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg);
 #define CsrWifiRouterMaPacketUnsubscribeReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
 #define CsrWifiRouterMaPacketUnsubscribeReqSerFree CsrWifiRouterPfree
 
-extern u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg);
+extern u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterMaPacketReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterMaPacketReqSizeof(void *msg);
 extern void CsrWifiRouterMaPacketReqSerFree(void *msg);
 
-extern u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterMaPacketResSizeof(void *msg);
+extern u8* CsrWifiRouterMaPacketResSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterMaPacketResDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterMaPacketResSizeof(void *msg);
 #define CsrWifiRouterMaPacketResSerFree CsrWifiRouterPfree
 
-extern u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg);
+extern u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterMaPacketCancelReqSizeof(void *msg);
 #define CsrWifiRouterMaPacketCancelReqSerFree CsrWifiRouterPfree
 
-extern u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg);
+extern u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg);
 #define CsrWifiRouterMaPacketSubscribeCfmSerFree CsrWifiRouterPfree
 
-extern u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg);
+extern u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg);
 #define CsrWifiRouterMaPacketUnsubscribeCfmSerFree CsrWifiRouterPfree
 
-extern u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg);
+extern u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterMaPacketCfmSizeof(void *msg);
 #define CsrWifiRouterMaPacketCfmSerFree CsrWifiRouterPfree
 
-extern u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg);
+extern u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiRouterMaPacketIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiRouterMaPacketIndSizeof(void *msg);
 extern void CsrWifiRouterMaPacketIndSerFree(void *msg);
 
 

drivers/staging/csr/csr_wifi_router_transport.c

@@ -61,14 +61,14 @@ void CsrWifiRouterTransportDeinit(unifi_priv_t *priv)
     }
 }
 
-void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLength)
+void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, size_t bufferLength)
 {
     CsrMsgConvMsgEntry* msgEntry;
     u16 primType;
     CsrSchedQid src;
     CsrSchedQid dest;
     u16 msgType;
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrWifiFsmEvent* msg;
 
     /* Decode the prim and message type */
@@ -163,9 +163,9 @@ static void CsrWifiRouterTransportSerialiseAndSend(u16 primType, void* msg)
 {
     CsrWifiFsmEvent* evt = (CsrWifiFsmEvent*)msg;
     CsrMsgConvMsgEntry* msgEntry;
-    CsrSize msgSize;
-    CsrSize encodeBufferLen = 0;
-    CsrSize offset = 0;
+    size_t msgSize;
+    size_t encodeBufferLen = 0;
+    size_t offset = 0;
     u8* encodeBuffer;
 
     unifi_trace(drvpriv, UDBG4, "CsrWifiRouterTransportSerialiseAndSend: primType=0x%.4X, msgType=0x%.4X\n",

drivers/staging/csr/csr_wifi_serialize_primitive_types.c

@@ -16,7 +16,7 @@
 #include "csr_wifi_msgconv.h"
 #include "csr_wifi_lib.h"
 
-void CsrUint24Des(u32 *v, u8 *buffer, CsrSize *offset)
+void CsrUint24Des(u32 *v, u8 *buffer, size_t *offset)
 {
     u32 val;
 
@@ -30,7 +30,7 @@ void CsrUint24Des(u32 *v, u8 *buffer, CsrSize *offset)
 
 
 /* Big endian :e.g WSC, TCLAS */
-void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset)
+void CsrUint16DesBigEndian(u16 *v, u8 *buffer, size_t *offset)
 {
     u16 val;
 
@@ -41,7 +41,7 @@ void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset)
 }
 
 
-void CsrUint24DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset)
+void CsrUint24DesBigEndian(u32 *v, u8 *buffer, size_t *offset)
 {
     u32 val;
 
@@ -54,7 +54,7 @@ void CsrUint24DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset)
 }
 
 
-void CsrUint32DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset)
+void CsrUint32DesBigEndian(u32 *v, u8 *buffer, size_t *offset)
 {
     u32 val;
 
@@ -68,7 +68,7 @@ void CsrUint32DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset)
 }
 
 
-void CsrUint24Ser(u8 *ptr, CsrSize *len, u32 v)
+void CsrUint24Ser(u8 *ptr, size_t *len, u32 v)
 {
     ptr[(*len) + 2] = (u8)((v & 0x00ff0000) >> 16);
     ptr[(*len) + 1] = (u8)((v & 0x0000ff00) >> 8);
@@ -79,7 +79,7 @@ void CsrUint24Ser(u8 *ptr, CsrSize *len, u32 v)
 
 
 /* Big endian :e.g WSC, TCLAS */
-void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, u16 v)
+void CsrUint16SerBigEndian(u8 *ptr, size_t *len, u16 v)
 {
     ptr[(*len)] = (u8)((v & 0xff00) >> 8);
     ptr[(*len) + 1] = (u8)((v & 0x00ff));
@@ -88,7 +88,7 @@ void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, u16 v)
 }
 
 
-void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, u32 v)
+void CsrUint32SerBigEndian(u8 *ptr, size_t *len, u32 v)
 {
     ptr[(*len)] = (u8)((v & 0xff000000) >> 24);
     ptr[(*len) + 1] = (u8)((v & 0x00ff0000) >> 16);
@@ -99,7 +99,7 @@ void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, u32 v)
 }
 
 
-void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, u32 v)
+void CsrUint24SerBigEndian(u8 *ptr, size_t *len, u32 v)
 {
     ptr[(*len)] = (u8)((v & 0x00ff0000) >> 16);
     ptr[(*len) + 1] = (u8)((v & 0x0000ff00) >> 8);
@@ -109,13 +109,13 @@ void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, u32 v)
 }
 
 
-CsrSize CsrWifiEventSizeof(void *msg)
+size_t CsrWifiEventSizeof(void *msg)
 {
     return 2;
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventSizeof);
 
-u8* CsrWifiEventSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *)msg;
     *len = 0;
@@ -124,23 +124,23 @@ u8* CsrWifiEventSer(u8 *ptr, CsrSize *len, void *msg)
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventSer);
 
-void* CsrWifiEventDes(u8 *buffer, CsrSize length)
+void* CsrWifiEventDes(u8 *buffer, size_t length)
 {
     CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *) CsrPmemAlloc(sizeof(CsrWifiFsmEvent));
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->type, buffer, &offset);
 
     return primitive;
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventDes);
 
-CsrSize CsrWifiEventCsrUint8Sizeof(void *msg)
+size_t CsrWifiEventCsrUint8Sizeof(void *msg)
 {
     return 3;
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Sizeof);
 
-u8* CsrWifiEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *)msg;
     *len = 0;
@@ -151,11 +151,11 @@ u8* CsrWifiEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Ser);
 
 
-void* CsrWifiEventCsrUint8Des(u8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint8Des(u8 *buffer, size_t length)
 {
     CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint8));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint8Des(&primitive->value, buffer, &offset);
 
@@ -164,14 +164,14 @@ void* CsrWifiEventCsrUint8Des(u8 *buffer, CsrSize length)
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Des);
 
 
-CsrSize CsrWifiEventCsrUint16Sizeof(void *msg)
+size_t CsrWifiEventCsrUint16Sizeof(void *msg)
 {
     return 4;
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Sizeof);
 
 
-u8* CsrWifiEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *)msg;
     *len = 0;
@@ -181,11 +181,11 @@ u8* CsrWifiEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Ser);
 
-void* CsrWifiEventCsrUint16Des(u8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint16Des(u8 *buffer, size_t length)
 {
     CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des(&primitive->value, buffer, &offset);
 
@@ -194,13 +194,13 @@ void* CsrWifiEventCsrUint16Des(u8 *buffer, CsrSize length)
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Des);
 
 
-CsrSize CsrWifiEventCsrUint32Sizeof(void *msg)
+size_t CsrWifiEventCsrUint32Sizeof(void *msg)
 {
     return 6;
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Sizeof);
 
-u8* CsrWifiEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *)msg;
     *len = 0;
@@ -211,11 +211,11 @@ u8* CsrWifiEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Ser);
 
 
-void* CsrWifiEventCsrUint32Des(u8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint32Des(u8 *buffer, size_t length)
 {
     CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint32));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint32Des(&primitive->value, buffer, &offset);
 
@@ -223,13 +223,13 @@ void* CsrWifiEventCsrUint32Des(u8 *buffer, CsrSize length)
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Des);
 
-CsrSize CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg)
+size_t CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg)
 {
     return 5;
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Sizeof);
 
-u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *)msg;
     *len = 0;
@@ -241,11 +241,11 @@ u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Ser);
 
 
-void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, size_t length)
 {
     CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16CsrUint8));
 
-    CsrSize offset = 0;
+    size_t offset = 0;
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des(&primitive->value16, buffer, &offset);
     CsrUint8Des(&primitive->value8, buffer, &offset);

drivers/staging/csr/csr_wifi_sme_serialize.c

@@ -24,9 +24,9 @@ void CsrWifiSmePfree(void *ptr)
 }
 
 
-CsrSize CsrWifiSmeAdhocConfigSetReqSizeof(void *msg)
+size_t CsrWifiSmeAdhocConfigSetReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2; /* u16 primitive->adHocConfig.atimWindowTu */
@@ -37,7 +37,7 @@ CsrSize CsrWifiSmeAdhocConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeAdhocConfigSetReq *primitive = (CsrWifiSmeAdhocConfigSetReq *)msg;
     *len = 0;
@@ -50,10 +50,10 @@ u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeAdhocConfigSetReq *primitive = (CsrWifiSmeAdhocConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -66,10 +66,10 @@ void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeBlacklistReqSizeof(void *msg)
+size_t CsrWifiSmeBlacklistReqSizeof(void *msg)
 {
     CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -86,7 +86,7 @@ CsrSize CsrWifiSmeBlacklistReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *)msg;
     *len = 0;
@@ -105,10 +105,10 @@ u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeBlacklistReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeBlacklistReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *) CsrPmemAlloc(sizeof(CsrWifiSmeBlacklistReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -140,10 +140,10 @@ void CsrWifiSmeBlacklistReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeCalibrationDataSetReqSizeof(void *msg)
+size_t CsrWifiSmeCalibrationDataSetReqSizeof(void *msg)
 {
     CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
     bufferSize += 2;                                /* u16 primitive->calibrationDataLength */
@@ -152,7 +152,7 @@ CsrSize CsrWifiSmeCalibrationDataSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *)msg;
     *len = 0;
@@ -166,10 +166,10 @@ u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -196,9 +196,9 @@ void CsrWifiSmeCalibrationDataSetReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg)
+size_t CsrWifiSmeCcxConfigSetReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -210,7 +210,7 @@ CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCcxConfigSetReq *primitive = (CsrWifiSmeCcxConfigSetReq *)msg;
     *len = 0;
@@ -224,10 +224,10 @@ u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCcxConfigSetReq *primitive = (CsrWifiSmeCcxConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -241,9 +241,9 @@ void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg)
+size_t CsrWifiSmeCoexConfigSetReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 29) */
     bufferSize += 1; /* u8 primitive->coexConfig.coexEnableSchemeManagement */
@@ -264,7 +264,7 @@ CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCoexConfigSetReq *primitive = (CsrWifiSmeCoexConfigSetReq *)msg;
     *len = 0;
@@ -287,10 +287,10 @@ u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCoexConfigSetReq *primitive = (CsrWifiSmeCoexConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -313,10 +313,10 @@ void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeConnectReqSizeof(void *msg)
+size_t CsrWifiSmeConnectReqSizeof(void *msg)
 {
     CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 57) */
     bufferSize += 2;                                                                     /* u16 primitive->interfaceTag */
@@ -337,7 +337,7 @@ CsrSize CsrWifiSmeConnectReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeConnectReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *)msg;
     *len = 0;
@@ -363,10 +363,10 @@ u8* CsrWifiSmeConnectReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeConnectReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -405,9 +405,9 @@ void CsrWifiSmeConnectReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeHostConfigSetReqSizeof(void *msg)
+size_t CsrWifiSmeHostConfigSetReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -417,7 +417,7 @@ CsrSize CsrWifiSmeHostConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeHostConfigSetReq *primitive = (CsrWifiSmeHostConfigSetReq *)msg;
     *len = 0;
@@ -429,10 +429,10 @@ u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeHostConfigSetReq *primitive = (CsrWifiSmeHostConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -444,9 +444,9 @@ void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeKeyReqSizeof(void *msg)
+size_t CsrWifiSmeKeyReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 65) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -469,7 +469,7 @@ CsrSize CsrWifiSmeKeyReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeKeyReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeKeyReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeKeyReq *primitive = (CsrWifiSmeKeyReq *)msg;
     *len = 0;
@@ -494,10 +494,10 @@ u8* CsrWifiSmeKeyReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeKeyReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeKeyReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeKeyReq *primitive = (CsrWifiSmeKeyReq *) CsrPmemAlloc(sizeof(CsrWifiSmeKeyReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -522,9 +522,9 @@ void* CsrWifiSmeKeyReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeMibConfigSetReqSizeof(void *msg)
+size_t CsrWifiSmeMibConfigSetReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 1; /* u8 primitive->mibConfig.unifiFixMaxTxDataRate */
@@ -536,7 +536,7 @@ CsrSize CsrWifiSmeMibConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMibConfigSetReq *primitive = (CsrWifiSmeMibConfigSetReq *)msg;
     *len = 0;
@@ -550,10 +550,10 @@ u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMibConfigSetReq *primitive = (CsrWifiSmeMibConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -567,10 +567,10 @@ void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeMibGetNextReqSizeof(void *msg)
+size_t CsrWifiSmeMibGetNextReqSizeof(void *msg)
 {
     CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
     bufferSize += 2;                             /* u16 primitive->mibAttributeLength */
@@ -579,7 +579,7 @@ CsrSize CsrWifiSmeMibGetNextReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *)msg;
     *len = 0;
@@ -593,10 +593,10 @@ u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetNextReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -623,10 +623,10 @@ void CsrWifiSmeMibGetNextReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeMibGetReqSizeof(void *msg)
+size_t CsrWifiSmeMibGetReqSizeof(void *msg)
 {
     CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
     bufferSize += 2;                             /* u16 primitive->mibAttributeLength */
@@ -635,7 +635,7 @@ CsrSize CsrWifiSmeMibGetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMibGetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *)msg;
     *len = 0;
@@ -649,10 +649,10 @@ u8* CsrWifiSmeMibGetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibGetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -679,10 +679,10 @@ void CsrWifiSmeMibGetReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeMibSetReqSizeof(void *msg)
+size_t CsrWifiSmeMibSetReqSizeof(void *msg)
 {
     CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
     bufferSize += 2;                             /* u16 primitive->mibAttributeLength */
@@ -691,7 +691,7 @@ CsrSize CsrWifiSmeMibSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMibSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *)msg;
     *len = 0;
@@ -705,10 +705,10 @@ u8* CsrWifiSmeMibSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMibSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -735,10 +735,10 @@ void CsrWifiSmeMibSetReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeMulticastAddressReqSizeof(void *msg)
+size_t CsrWifiSmeMulticastAddressReqSizeof(void *msg)
 {
     CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -755,7 +755,7 @@ CsrSize CsrWifiSmeMulticastAddressReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *)msg;
     *len = 0;
@@ -774,10 +774,10 @@ u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMulticastAddressReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -809,10 +809,10 @@ void CsrWifiSmeMulticastAddressReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmePacketFilterSetReqSizeof(void *msg)
+size_t CsrWifiSmePacketFilterSetReqSizeof(void *msg)
 {
     CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2;                       /* u16 primitive->interfaceTag */
@@ -824,7 +824,7 @@ CsrSize CsrWifiSmePacketFilterSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *)msg;
     *len = 0;
@@ -841,10 +841,10 @@ u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePacketFilterSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -874,10 +874,10 @@ void CsrWifiSmePacketFilterSetReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmePmkidReqSizeof(void *msg)
+size_t CsrWifiSmePmkidReqSizeof(void *msg)
 {
     CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 29) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -895,7 +895,7 @@ CsrSize CsrWifiSmePmkidReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmePmkidReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePmkidReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *)msg;
     *len = 0;
@@ -915,10 +915,10 @@ u8* CsrWifiSmePmkidReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmePmkidReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmePmkidReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -951,9 +951,9 @@ void CsrWifiSmePmkidReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg)
+size_t CsrWifiSmePowerConfigSetReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 1; /* CsrWifiSmePowerSaveLevel primitive->powerConfig.powerSaveLevel */
@@ -967,7 +967,7 @@ CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmePowerConfigSetReq *primitive = (CsrWifiSmePowerConfigSetReq *)msg;
     *len = 0;
@@ -983,10 +983,10 @@ u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmePowerConfigSetReq *primitive = (CsrWifiSmePowerConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1002,9 +1002,9 @@ void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg)
+size_t CsrWifiSmeRoamingConfigSetReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 70) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -1038,7 +1038,7 @@ CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeRoamingConfigSetReq *primitive = (CsrWifiSmeRoamingConfigSetReq *)msg;
     *len = 0;
@@ -1074,10 +1074,10 @@ u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeRoamingConfigSetReq *primitive = (CsrWifiSmeRoamingConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1113,10 +1113,10 @@ void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeScanConfigSetReqSizeof(void *msg)
+size_t CsrWifiSmeScanConfigSetReqSizeof(void *msg)
 {
     CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 63) */
     {
@@ -1145,7 +1145,7 @@ CsrSize CsrWifiSmeScanConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *)msg;
     *len = 0;
@@ -1179,10 +1179,10 @@ u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1229,10 +1229,10 @@ void CsrWifiSmeScanConfigSetReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeScanFullReqSizeof(void *msg)
+size_t CsrWifiSmeScanFullReqSizeof(void *msg)
 {
     CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 52) */
     bufferSize += 1; /* u8 primitive->ssidCount */
@@ -1256,7 +1256,7 @@ CsrSize CsrWifiSmeScanFullReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeScanFullReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanFullReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *)msg;
     *len = 0;
@@ -1288,10 +1288,10 @@ u8* CsrWifiSmeScanFullReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeScanFullReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeScanFullReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanFullReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1348,9 +1348,9 @@ void CsrWifiSmeScanFullReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg)
+size_t CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -1364,7 +1364,7 @@ CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeSmeStaConfigSetReq *primitive = (CsrWifiSmeSmeStaConfigSetReq *)msg;
     *len = 0;
@@ -1380,10 +1380,10 @@ u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeSmeStaConfigSetReq *primitive = (CsrWifiSmeSmeStaConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1399,10 +1399,10 @@ void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeTspecReqSizeof(void *msg)
+size_t CsrWifiSmeTspecReqSizeof(void *msg)
 {
     CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
     bufferSize += 2;                      /* u16 primitive->interfaceTag */
@@ -1418,7 +1418,7 @@ CsrSize CsrWifiSmeTspecReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeTspecReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeTspecReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *)msg;
     *len = 0;
@@ -1442,10 +1442,10 @@ u8* CsrWifiSmeTspecReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeTspecReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeTspecReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1488,10 +1488,10 @@ void CsrWifiSmeTspecReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeWifiFlightmodeReqSizeof(void *msg)
+size_t CsrWifiSmeWifiFlightmodeReqSizeof(void *msg)
 {
     CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
     bufferSize += 6; /* u8 primitive->address.a[6] */
@@ -1508,7 +1508,7 @@ CsrSize CsrWifiSmeWifiFlightmodeReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *)msg;
     *len = 0;
@@ -1530,10 +1530,10 @@ u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiFlightmodeReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1580,10 +1580,10 @@ void CsrWifiSmeWifiFlightmodeReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeWifiOnReqSizeof(void *msg)
+size_t CsrWifiSmeWifiOnReqSizeof(void *msg)
 {
     CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
     bufferSize += 6; /* u8 primitive->address.a[6] */
@@ -1600,7 +1600,7 @@ CsrSize CsrWifiSmeWifiOnReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *)msg;
     *len = 0;
@@ -1622,10 +1622,10 @@ u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeWifiOnReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeWifiOnReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1672,10 +1672,10 @@ void CsrWifiSmeWifiOnReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg)
+size_t CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg)
 {
     CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 37) */
     bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsidsCount */
@@ -1691,7 +1691,7 @@ CsrSize CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *)msg;
     *len = 0;
@@ -1709,10 +1709,10 @@ u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1743,9 +1743,9 @@ void CsrWifiSmeCloakedSsidsSetReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg)
+size_t CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 1; /* CsrWifiSme80211dTrustLevel primitive->deviceConfig.trustLevel */
@@ -1756,7 +1756,7 @@ CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeSmeCommonConfigSetReq *primitive = (CsrWifiSmeSmeCommonConfigSetReq *)msg;
     *len = 0;
@@ -1769,10 +1769,10 @@ u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeSmeCommonConfigSetReq *primitive = (CsrWifiSmeSmeCommonConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1785,10 +1785,10 @@ void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeWpsConfigurationReqSizeof(void *msg)
+size_t CsrWifiSmeWpsConfigurationReqSizeof(void *msg)
 {
     CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 240) */
     bufferSize += 1;  /* u8 primitive->wpsConfig.wpsVersion */
@@ -1818,7 +1818,7 @@ CsrSize CsrWifiSmeWpsConfigurationReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *)msg;
     *len = 0;
@@ -1850,10 +1850,10 @@ u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWpsConfigurationReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1898,10 +1898,10 @@ void CsrWifiSmeWpsConfigurationReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeSetReqSizeof(void *msg)
+size_t CsrWifiSmeSetReqSizeof(void *msg)
 {
     CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 4;                     /* u32 primitive->dataLength */
@@ -1910,7 +1910,7 @@ CsrSize CsrWifiSmeSetReqSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeSetReqSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSetReqSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *)msg;
     *len = 0;
@@ -1924,10 +1924,10 @@ u8* CsrWifiSmeSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeSetReqDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeSetReqDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSetReq));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1954,9 +1954,9 @@ void CsrWifiSmeSetReqSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -1968,7 +1968,7 @@ CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeAdhocConfigGetCfm *primitive = (CsrWifiSmeAdhocConfigGetCfm *)msg;
     *len = 0;
@@ -1982,10 +1982,10 @@ u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeAdhocConfigGetCfm *primitive = (CsrWifiSmeAdhocConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -1999,10 +1999,10 @@ void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg)
+size_t CsrWifiSmeAssociationCompleteIndSizeof(void *msg)
 {
     CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 98) */
     bufferSize += 2;                                                     /* u16 primitive->interfaceTag */
@@ -2043,7 +2043,7 @@ CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *)msg;
     *len = 0;
@@ -2104,10 +2104,10 @@ u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAssociationCompleteInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2211,9 +2211,9 @@ void CsrWifiSmeAssociationCompleteIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeAssociationStartIndSizeof(void *msg)
+size_t CsrWifiSmeAssociationStartIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 44) */
     bufferSize += 2;  /* u16 primitive->interfaceTag */
@@ -2224,7 +2224,7 @@ CsrSize CsrWifiSmeAssociationStartIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeAssociationStartInd *primitive = (CsrWifiSmeAssociationStartInd *)msg;
     *len = 0;
@@ -2237,10 +2237,10 @@ u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeAssociationStartInd *primitive = (CsrWifiSmeAssociationStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAssociationStartInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2253,10 +2253,10 @@ void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeBlacklistCfmSizeof(void *msg)
+size_t CsrWifiSmeBlacklistCfmSizeof(void *msg)
 {
     CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -2274,7 +2274,7 @@ CsrSize CsrWifiSmeBlacklistCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *)msg;
     *len = 0;
@@ -2294,10 +2294,10 @@ u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeBlacklistCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2330,10 +2330,10 @@ void CsrWifiSmeBlacklistCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg)
+size_t CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg)
 {
     CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2;                                /* CsrResult primitive->status */
@@ -2343,7 +2343,7 @@ CsrSize CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *)msg;
     *len = 0;
@@ -2358,10 +2358,10 @@ u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2389,9 +2389,9 @@ void CsrWifiSmeCalibrationDataGetCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeCcxConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmeCcxConfigGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -2404,7 +2404,7 @@ CsrSize CsrWifiSmeCcxConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCcxConfigGetCfm *primitive = (CsrWifiSmeCcxConfigGetCfm *)msg;
     *len = 0;
@@ -2419,10 +2419,10 @@ u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCcxConfigGetCfm *primitive = (CsrWifiSmeCcxConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2437,9 +2437,9 @@ void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeCcxConfigSetCfmSizeof(void *msg)
+size_t CsrWifiSmeCcxConfigSetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -2448,7 +2448,7 @@ CsrSize CsrWifiSmeCcxConfigSetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCcxConfigSetCfm *primitive = (CsrWifiSmeCcxConfigSetCfm *)msg;
     *len = 0;
@@ -2459,10 +2459,10 @@ u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCcxConfigSetCfm *primitive = (CsrWifiSmeCcxConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigSetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2473,9 +2473,9 @@ void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmeCoexConfigGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 31) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -2497,7 +2497,7 @@ CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCoexConfigGetCfm *primitive = (CsrWifiSmeCoexConfigGetCfm *)msg;
     *len = 0;
@@ -2521,10 +2521,10 @@ u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCoexConfigGetCfm *primitive = (CsrWifiSmeCoexConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2548,9 +2548,9 @@ void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeCoexInfoGetCfmSizeof(void *msg)
+size_t CsrWifiSmeCoexInfoGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 24) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -2568,7 +2568,7 @@ CsrSize CsrWifiSmeCoexInfoGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCoexInfoGetCfm *primitive = (CsrWifiSmeCoexInfoGetCfm *)msg;
     *len = 0;
@@ -2588,10 +2588,10 @@ u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCoexInfoGetCfm *primitive = (CsrWifiSmeCoexInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexInfoGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2611,9 +2611,9 @@ void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeConnectCfmSizeof(void *msg)
+size_t CsrWifiSmeConnectCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -2622,7 +2622,7 @@ CsrSize CsrWifiSmeConnectCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeConnectCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeConnectCfm *primitive = (CsrWifiSmeConnectCfm *)msg;
     *len = 0;
@@ -2633,10 +2633,10 @@ u8* CsrWifiSmeConnectCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeConnectCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeConnectCfm *primitive = (CsrWifiSmeConnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2647,10 +2647,10 @@ void* CsrWifiSmeConnectCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg)
 {
     CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 59) */
     bufferSize += 2;                                                                     /* u16 primitive->interfaceTag */
@@ -2672,7 +2672,7 @@ CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *)msg;
     *len = 0;
@@ -2699,10 +2699,10 @@ u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2742,10 +2742,10 @@ void CsrWifiSmeConnectionConfigGetCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg)
+size_t CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg)
 {
     CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 96) */
     bufferSize += 2;                                                     /* u16 primitive->interfaceTag */
@@ -2785,7 +2785,7 @@ CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *)msg;
     *len = 0;
@@ -2845,10 +2845,10 @@ u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionInfoGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2951,9 +2951,9 @@ void CsrWifiSmeConnectionInfoGetCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeConnectionQualityIndSizeof(void *msg)
+size_t CsrWifiSmeConnectionQualityIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -2963,7 +2963,7 @@ CsrSize CsrWifiSmeConnectionQualityIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeConnectionQualityInd *primitive = (CsrWifiSmeConnectionQualityInd *)msg;
     *len = 0;
@@ -2975,10 +2975,10 @@ u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeConnectionQualityInd *primitive = (CsrWifiSmeConnectionQualityInd *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionQualityInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -2990,9 +2990,9 @@ void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg)
+size_t CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 101) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -3026,7 +3026,7 @@ CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeConnectionStatsGetCfm *primitive = (CsrWifiSmeConnectionStatsGetCfm *)msg;
     *len = 0;
@@ -3062,10 +3062,10 @@ u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeConnectionStatsGetCfm *primitive = (CsrWifiSmeConnectionStatsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionStatsGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3101,9 +3101,9 @@ void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg)
+size_t CsrWifiSmeDisconnectCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -3112,7 +3112,7 @@ CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeDisconnectCfm *primitive = (CsrWifiSmeDisconnectCfm *)msg;
     *len = 0;
@@ -3123,10 +3123,10 @@ u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeDisconnectCfm *primitive = (CsrWifiSmeDisconnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeDisconnectCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3137,9 +3137,9 @@ void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeHostConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmeHostConfigGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -3150,7 +3150,7 @@ CsrSize CsrWifiSmeHostConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeHostConfigGetCfm *primitive = (CsrWifiSmeHostConfigGetCfm *)msg;
     *len = 0;
@@ -3163,10 +3163,10 @@ u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeHostConfigGetCfm *primitive = (CsrWifiSmeHostConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3179,9 +3179,9 @@ void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeHostConfigSetCfmSizeof(void *msg)
+size_t CsrWifiSmeHostConfigSetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -3190,7 +3190,7 @@ CsrSize CsrWifiSmeHostConfigSetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeHostConfigSetCfm *primitive = (CsrWifiSmeHostConfigSetCfm *)msg;
     *len = 0;
@@ -3201,10 +3201,10 @@ u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeHostConfigSetCfm *primitive = (CsrWifiSmeHostConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigSetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3215,9 +3215,9 @@ void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeIbssStationIndSizeof(void *msg)
+size_t CsrWifiSmeIbssStationIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 6; /* u8 primitive->address.a[6] */
@@ -3226,7 +3226,7 @@ CsrSize CsrWifiSmeIbssStationIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeIbssStationInd *primitive = (CsrWifiSmeIbssStationInd *)msg;
     *len = 0;
@@ -3237,10 +3237,10 @@ u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeIbssStationIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeIbssStationIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeIbssStationInd *primitive = (CsrWifiSmeIbssStationInd *) CsrPmemAlloc(sizeof(CsrWifiSmeIbssStationInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3251,9 +3251,9 @@ void* CsrWifiSmeIbssStationIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeKeyCfmSizeof(void *msg)
+size_t CsrWifiSmeKeyCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -3265,7 +3265,7 @@ CsrSize CsrWifiSmeKeyCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeKeyCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeKeyCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeKeyCfm *primitive = (CsrWifiSmeKeyCfm *)msg;
     *len = 0;
@@ -3279,10 +3279,10 @@ u8* CsrWifiSmeKeyCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeKeyCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeKeyCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeKeyCfm *primitive = (CsrWifiSmeKeyCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeKeyCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3296,9 +3296,9 @@ void* CsrWifiSmeKeyCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeLinkQualityGetCfmSizeof(void *msg)
+size_t CsrWifiSmeLinkQualityGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -3309,7 +3309,7 @@ CsrSize CsrWifiSmeLinkQualityGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeLinkQualityGetCfm *primitive = (CsrWifiSmeLinkQualityGetCfm *)msg;
     *len = 0;
@@ -3322,10 +3322,10 @@ u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeLinkQualityGetCfm *primitive = (CsrWifiSmeLinkQualityGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeLinkQualityGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3338,10 +3338,10 @@ void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg)
+size_t CsrWifiSmeMediaStatusIndSizeof(void *msg)
 {
     CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 99) */
     bufferSize += 2;                                                     /* u16 primitive->interfaceTag */
@@ -3383,7 +3383,7 @@ CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *)msg;
     *len = 0;
@@ -3445,10 +3445,10 @@ u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *) CsrPmemAlloc(sizeof(CsrWifiSmeMediaStatusInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3553,9 +3553,9 @@ void CsrWifiSmeMediaStatusIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmeMibConfigGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -3568,7 +3568,7 @@ CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMibConfigGetCfm *primitive = (CsrWifiSmeMibConfigGetCfm *)msg;
     *len = 0;
@@ -3583,10 +3583,10 @@ u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMibConfigGetCfm *primitive = (CsrWifiSmeMibConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3601,10 +3601,10 @@ void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeMibGetCfmSizeof(void *msg)
+size_t CsrWifiSmeMibGetCfmSizeof(void *msg)
 {
     CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2;                             /* CsrResult primitive->status */
@@ -3614,7 +3614,7 @@ CsrSize CsrWifiSmeMibGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *)msg;
     *len = 0;
@@ -3629,10 +3629,10 @@ u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3660,10 +3660,10 @@ void CsrWifiSmeMibGetCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeMibGetNextCfmSizeof(void *msg)
+size_t CsrWifiSmeMibGetNextCfmSizeof(void *msg)
 {
     CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2;                             /* CsrResult primitive->status */
@@ -3673,7 +3673,7 @@ CsrSize CsrWifiSmeMibGetNextCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *)msg;
     *len = 0;
@@ -3688,10 +3688,10 @@ u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetNextCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3719,9 +3719,9 @@ void CsrWifiSmeMibGetNextCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeMicFailureIndSizeof(void *msg)
+size_t CsrWifiSmeMicFailureIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -3733,7 +3733,7 @@ CsrSize CsrWifiSmeMicFailureIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMicFailureInd *primitive = (CsrWifiSmeMicFailureInd *)msg;
     *len = 0;
@@ -3747,10 +3747,10 @@ u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMicFailureIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMicFailureIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMicFailureInd *primitive = (CsrWifiSmeMicFailureInd *) CsrPmemAlloc(sizeof(CsrWifiSmeMicFailureInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3764,10 +3764,10 @@ void* CsrWifiSmeMicFailureIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeMulticastAddressCfmSizeof(void *msg)
+size_t CsrWifiSmeMulticastAddressCfmSizeof(void *msg)
 {
     CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -3785,7 +3785,7 @@ CsrSize CsrWifiSmeMulticastAddressCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *)msg;
     *len = 0;
@@ -3805,10 +3805,10 @@ u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMulticastAddressCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3841,9 +3841,9 @@ void CsrWifiSmeMulticastAddressCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmePacketFilterSetCfmSizeof(void *msg)
+size_t CsrWifiSmePacketFilterSetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -3852,7 +3852,7 @@ CsrSize CsrWifiSmePacketFilterSetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmePacketFilterSetCfm *primitive = (CsrWifiSmePacketFilterSetCfm *)msg;
     *len = 0;
@@ -3863,10 +3863,10 @@ u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmePacketFilterSetCfm *primitive = (CsrWifiSmePacketFilterSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePacketFilterSetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3877,9 +3877,9 @@ void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg)
+size_t CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -3888,7 +3888,7 @@ CsrSize CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmePermanentMacAddressGetCfm *primitive = (CsrWifiSmePermanentMacAddressGetCfm *)msg;
     *len = 0;
@@ -3899,10 +3899,10 @@ u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmePermanentMacAddressGetCfm *primitive = (CsrWifiSmePermanentMacAddressGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePermanentMacAddressGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3913,10 +3913,10 @@ void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg)
+size_t CsrWifiSmePmkidCandidateListIndSizeof(void *msg)
 {
     CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -3933,7 +3933,7 @@ CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *)msg;
     *len = 0;
@@ -3952,10 +3952,10 @@ u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidCandidateListInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -3987,10 +3987,10 @@ void CsrWifiSmePmkidCandidateListIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmePmkidCfmSizeof(void *msg)
+size_t CsrWifiSmePmkidCfmSizeof(void *msg)
 {
     CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 31) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -4009,7 +4009,7 @@ CsrSize CsrWifiSmePmkidCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmePmkidCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePmkidCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *)msg;
     *len = 0;
@@ -4030,10 +4030,10 @@ u8* CsrWifiSmePmkidCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmePmkidCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmePmkidCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -4067,9 +4067,9 @@ void CsrWifiSmePmkidCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmePowerConfigGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -4084,7 +4084,7 @@ CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmePowerConfigGetCfm *primitive = (CsrWifiSmePowerConfigGetCfm *)msg;
     *len = 0;
@@ -4101,10 +4101,10 @@ u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmePowerConfigGetCfm *primitive = (CsrWifiSmePowerConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -4121,9 +4121,9 @@ void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg)
+size_t CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -4135,7 +4135,7 @@ CsrSize CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeRegulatoryDomainInfoGetCfm *primitive = (CsrWifiSmeRegulatoryDomainInfoGetCfm *)msg;
     *len = 0;
@@ -4149,10 +4149,10 @@ u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeRegulatoryDomainInfoGetCfm *primitive = (CsrWifiSmeRegulatoryDomainInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRegulatoryDomainInfoGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -4166,9 +4166,9 @@ void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeRoamCompleteIndSizeof(void *msg)
+size_t CsrWifiSmeRoamCompleteIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -4177,7 +4177,7 @@ CsrSize CsrWifiSmeRoamCompleteIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeRoamCompleteInd *primitive = (CsrWifiSmeRoamCompleteInd *)msg;
     *len = 0;
@@ -4188,10 +4188,10 @@ u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeRoamCompleteInd *primitive = (CsrWifiSmeRoamCompleteInd *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamCompleteInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -4202,9 +4202,9 @@ void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeRoamStartIndSizeof(void *msg)
+size_t CsrWifiSmeRoamStartIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -4214,7 +4214,7 @@ CsrSize CsrWifiSmeRoamStartIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeRoamStartInd *primitive = (CsrWifiSmeRoamStartInd *)msg;
     *len = 0;
@@ -4226,10 +4226,10 @@ u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeRoamStartIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamStartIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeRoamStartInd *primitive = (CsrWifiSmeRoamStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamStartInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -4241,9 +4241,9 @@ void* CsrWifiSmeRoamStartIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 72) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -4278,7 +4278,7 @@ CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeRoamingConfigGetCfm *primitive = (CsrWifiSmeRoamingConfigGetCfm *)msg;
     *len = 0;
@@ -4315,10 +4315,10 @@ u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeRoamingConfigGetCfm *primitive = (CsrWifiSmeRoamingConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -4355,9 +4355,9 @@ void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg)
+size_t CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -4366,7 +4366,7 @@ CsrSize CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeRoamingConfigSetCfm *primitive = (CsrWifiSmeRoamingConfigSetCfm *)msg;
     *len = 0;
@@ -4377,10 +4377,10 @@ u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeRoamingConfigSetCfm *primitive = (CsrWifiSmeRoamingConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigSetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -4391,10 +4391,10 @@ void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeScanConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmeScanConfigGetCfmSizeof(void *msg)
 {
     CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 65) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -4424,7 +4424,7 @@ CsrSize CsrWifiSmeScanConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *)msg;
     *len = 0;
@@ -4459,10 +4459,10 @@ u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -4510,10 +4510,10 @@ void CsrWifiSmeScanConfigGetCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeScanResultIndSizeof(void *msg)
+size_t CsrWifiSmeScanResultIndSizeof(void *msg)
 {
     CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 149) */
     bufferSize += 32;                                          /* u8 primitive->result.ssid.ssid[32] */
@@ -4590,7 +4590,7 @@ CsrSize CsrWifiSmeScanResultIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanResultIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *)msg;
     *len = 0;
@@ -4672,10 +4672,10 @@ u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeScanResultIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -4803,10 +4803,10 @@ void CsrWifiSmeScanResultIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
+size_t CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
 {
     CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 153) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -4891,7 +4891,7 @@ CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *)msg;
     *len = 0;
@@ -4981,10 +4981,10 @@ u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultsGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5132,9 +5132,9 @@ void CsrWifiSmeScanResultsGetCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -5149,7 +5149,7 @@ CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeSmeStaConfigGetCfm *primitive = (CsrWifiSmeSmeStaConfigGetCfm *)msg;
     *len = 0;
@@ -5166,10 +5166,10 @@ u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeSmeStaConfigGetCfm *primitive = (CsrWifiSmeSmeStaConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5186,9 +5186,9 @@ void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg)
+size_t CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
     bufferSize += 2; /* u16 primitive->interfaceTag */
@@ -5197,7 +5197,7 @@ CsrSize CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeSmeStaConfigSetCfm *primitive = (CsrWifiSmeSmeStaConfigSetCfm *)msg;
     *len = 0;
@@ -5208,10 +5208,10 @@ u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeSmeStaConfigSetCfm *primitive = (CsrWifiSmeSmeStaConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigSetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5222,9 +5222,9 @@ void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg)
+size_t CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -5239,7 +5239,7 @@ CsrSize CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeStationMacAddressGetCfm *primitive = (CsrWifiSmeStationMacAddressGetCfm *)msg;
     *len = 0;
@@ -5256,10 +5256,10 @@ u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeStationMacAddressGetCfm *primitive = (CsrWifiSmeStationMacAddressGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeStationMacAddressGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5276,10 +5276,10 @@ void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeTspecIndSizeof(void *msg)
+size_t CsrWifiSmeTspecIndSizeof(void *msg)
 {
     CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2;                      /* u16 primitive->interfaceTag */
@@ -5291,7 +5291,7 @@ CsrSize CsrWifiSmeTspecIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeTspecIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeTspecIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *)msg;
     *len = 0;
@@ -5308,10 +5308,10 @@ u8* CsrWifiSmeTspecIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeTspecIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeTspecIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5341,10 +5341,10 @@ void CsrWifiSmeTspecIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeTspecCfmSizeof(void *msg)
+size_t CsrWifiSmeTspecCfmSizeof(void *msg)
 {
     CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2;                      /* u16 primitive->interfaceTag */
@@ -5357,7 +5357,7 @@ CsrSize CsrWifiSmeTspecCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeTspecCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeTspecCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *)msg;
     *len = 0;
@@ -5375,10 +5375,10 @@ u8* CsrWifiSmeTspecCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeTspecCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeTspecCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5409,10 +5409,10 @@ void CsrWifiSmeTspecCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeVersionsGetCfmSizeof(void *msg)
+size_t CsrWifiSmeVersionsGetCfmSizeof(void *msg)
 {
     CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 33) */
     bufferSize += 2;                                                                                    /* CsrResult primitive->status */
@@ -5429,7 +5429,7 @@ CsrSize CsrWifiSmeVersionsGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *)msg;
     *len = 0;
@@ -5448,10 +5448,10 @@ u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeVersionsGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5479,10 +5479,10 @@ void CsrWifiSmeVersionsGetCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg)
+size_t CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg)
 {
     CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 39) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -5499,7 +5499,7 @@ CsrSize CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *)msg;
     *len = 0;
@@ -5518,10 +5518,10 @@ u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5553,9 +5553,9 @@ void CsrWifiSmeCloakedSsidsGetCfmSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeWifiOnIndSizeof(void *msg)
+size_t CsrWifiSmeWifiOnIndSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 6; /* u8 primitive->address.a[6] */
@@ -5563,7 +5563,7 @@ CsrSize CsrWifiSmeWifiOnIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeWifiOnInd *primitive = (CsrWifiSmeWifiOnInd *)msg;
     *len = 0;
@@ -5573,10 +5573,10 @@ u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeWifiOnIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeWifiOnIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeWifiOnInd *primitive = (CsrWifiSmeWifiOnInd *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5586,9 +5586,9 @@ void* CsrWifiSmeWifiOnIndDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg)
+size_t CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -5600,7 +5600,7 @@ CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeSmeCommonConfigGetCfm *primitive = (CsrWifiSmeSmeCommonConfigGetCfm *)msg;
     *len = 0;
@@ -5614,10 +5614,10 @@ u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeSmeCommonConfigGetCfm *primitive = (CsrWifiSmeSmeCommonConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5631,9 +5631,9 @@ void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg)
+size_t CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg)
 {
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -5643,7 +5643,7 @@ CsrSize CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeInterfaceCapabilityGetCfm *primitive = (CsrWifiSmeInterfaceCapabilityGetCfm *)msg;
     *len = 0;
@@ -5655,10 +5655,10 @@ u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeInterfaceCapabilityGetCfm *primitive = (CsrWifiSmeInterfaceCapabilityGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeInterfaceCapabilityGetCfm));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5670,10 +5670,10 @@ void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, CsrSize length)
 }
 
 
-CsrSize CsrWifiSmeErrorIndSizeof(void *msg)
+size_t CsrWifiSmeErrorIndSizeof(void *msg)
 {
     CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 3) */
     bufferSize += (primitive->errorMessage?CsrStrLen(primitive->errorMessage) : 0) + 1; /* char* primitive->errorMessage (0 byte len + 1 for NULL Term) */
@@ -5681,7 +5681,7 @@ CsrSize CsrWifiSmeErrorIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeErrorIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeErrorIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *)msg;
     *len = 0;
@@ -5691,10 +5691,10 @@ u8* CsrWifiSmeErrorIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeErrorIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeErrorIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *) CsrPmemAlloc(sizeof(CsrWifiSmeErrorInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5712,10 +5712,10 @@ void CsrWifiSmeErrorIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeInfoIndSizeof(void *msg)
+size_t CsrWifiSmeInfoIndSizeof(void *msg)
 {
     CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 3) */
     bufferSize += (primitive->infoMessage?CsrStrLen(primitive->infoMessage) : 0) + 1; /* char* primitive->infoMessage (0 byte len + 1 for NULL Term) */
@@ -5723,7 +5723,7 @@ CsrSize CsrWifiSmeInfoIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeInfoIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeInfoIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *)msg;
     *len = 0;
@@ -5733,10 +5733,10 @@ u8* CsrWifiSmeInfoIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeInfoIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeInfoIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *) CsrPmemAlloc(sizeof(CsrWifiSmeInfoInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
@@ -5754,10 +5754,10 @@ void CsrWifiSmeInfoIndSerFree(void *voidPrimitivePointer)
 }
 
 
-CsrSize CsrWifiSmeCoreDumpIndSizeof(void *msg)
+size_t CsrWifiSmeCoreDumpIndSizeof(void *msg)
 {
     CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *) msg;
-    CsrSize bufferSize = 2;
+    size_t bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 4;                     /* u32 primitive->dataLength */
@@ -5766,7 +5766,7 @@ CsrSize CsrWifiSmeCoreDumpIndSizeof(void *msg)
 }
 
 
-u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, size_t *len, void *msg)
 {
     CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *)msg;
     *len = 0;
@@ -5780,10 +5780,10 @@ u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, CsrSize length)
+void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, size_t length)
 {
     CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *) CsrPmemAlloc(sizeof(CsrWifiSmeCoreDumpInd));
-    CsrSize offset;
+    size_t offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);

drivers/staging/csr/csr_wifi_sme_serialize.h

@@ -35,14 +35,14 @@ extern void CsrWifiSmePfree(void *ptr);
 #define CsrWifiSmeAdhocConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeAdhocConfigGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeAdhocConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeAdhocConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeAdhocConfigSetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeBlacklistReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeBlacklistReqSizeof(void *msg);
+extern u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeBlacklistReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeBlacklistReqSizeof(void *msg);
 extern void CsrWifiSmeBlacklistReqSerFree(void *msg);
 
 #define CsrWifiSmeCalibrationDataGetReqSer CsrWifiEventSer
@@ -50,9 +50,9 @@ extern void CsrWifiSmeBlacklistReqSerFree(void *msg);
 #define CsrWifiSmeCalibrationDataGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeCalibrationDataGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCalibrationDataSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCalibrationDataSetReqSizeof(void *msg);
 extern void CsrWifiSmeCalibrationDataSetReqSerFree(void *msg);
 
 #define CsrWifiSmeCcxConfigGetReqSer CsrWifiEventCsrUint16Ser
@@ -60,9 +60,9 @@ extern void CsrWifiSmeCalibrationDataSetReqSerFree(void *msg);
 #define CsrWifiSmeCcxConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeCcxConfigGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCcxConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeCcxConfigSetReqSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeCoexConfigGetReqSer CsrWifiEventSer
@@ -70,9 +70,9 @@ extern CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeCoexConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeCoexConfigGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCoexConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeCoexConfigSetReqSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeCoexInfoGetReqSer CsrWifiEventSer
@@ -80,9 +80,9 @@ extern CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeCoexInfoGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeCoexInfoGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeConnectReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeConnectReqSizeof(void *msg);
+extern u8* CsrWifiSmeConnectReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeConnectReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeConnectReqSizeof(void *msg);
 extern void CsrWifiSmeConnectReqSerFree(void *msg);
 
 #define CsrWifiSmeConnectionConfigGetReqSer CsrWifiEventCsrUint16Ser
@@ -120,14 +120,14 @@ extern void CsrWifiSmeConnectReqSerFree(void *msg);
 #define CsrWifiSmeHostConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeHostConfigGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeHostConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeHostConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeHostConfigSetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeKeyReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeKeyReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeKeyReqSizeof(void *msg);
+extern u8* CsrWifiSmeKeyReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeKeyReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeKeyReqSizeof(void *msg);
 #define CsrWifiSmeKeyReqSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeLinkQualityGetReqSer CsrWifiEventCsrUint16Ser
@@ -140,34 +140,34 @@ extern CsrSize CsrWifiSmeKeyReqSizeof(void *msg);
 #define CsrWifiSmeMibConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeMibConfigGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMibConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMibConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeMibConfigSetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMibGetNextReqSizeof(void *msg);
+extern u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMibGetNextReqSizeof(void *msg);
 extern void CsrWifiSmeMibGetNextReqSerFree(void *msg);
 
-extern u8* CsrWifiSmeMibGetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMibGetReqSizeof(void *msg);
+extern u8* CsrWifiSmeMibGetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMibGetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMibGetReqSizeof(void *msg);
 extern void CsrWifiSmeMibGetReqSerFree(void *msg);
 
-extern u8* CsrWifiSmeMibSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMibSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeMibSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMibSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMibSetReqSizeof(void *msg);
 extern void CsrWifiSmeMibSetReqSerFree(void *msg);
 
-extern u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMulticastAddressReqSizeof(void *msg);
+extern u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMulticastAddressReqSizeof(void *msg);
 extern void CsrWifiSmeMulticastAddressReqSerFree(void *msg);
 
-extern u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmePacketFilterSetReqSizeof(void *msg);
+extern u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmePacketFilterSetReqSizeof(void *msg);
 extern void CsrWifiSmePacketFilterSetReqSerFree(void *msg);
 
 #define CsrWifiSmePermanentMacAddressGetReqSer CsrWifiEventSer
@@ -175,9 +175,9 @@ extern void CsrWifiSmePacketFilterSetReqSerFree(void *msg);
 #define CsrWifiSmePermanentMacAddressGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmePermanentMacAddressGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmePmkidReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePmkidReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmePmkidReqSizeof(void *msg);
+extern u8* CsrWifiSmePmkidReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmePmkidReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmePmkidReqSizeof(void *msg);
 extern void CsrWifiSmePmkidReqSerFree(void *msg);
 
 #define CsrWifiSmePowerConfigGetReqSer CsrWifiEventSer
@@ -185,9 +185,9 @@ extern void CsrWifiSmePmkidReqSerFree(void *msg);
 #define CsrWifiSmePowerConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmePowerConfigGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmePowerConfigSetReqSizeof(void *msg);
 #define CsrWifiSmePowerConfigSetReqSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeRegulatoryDomainInfoGetReqSer CsrWifiEventSer
@@ -200,9 +200,9 @@ extern CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeRoamingConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeRoamingConfigGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeRoamingConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeRoamingConfigSetReqSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeScanConfigGetReqSer CsrWifiEventSer
@@ -210,14 +210,14 @@ extern CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeScanConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeScanConfigGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeScanConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeScanConfigSetReqSizeof(void *msg);
 extern void CsrWifiSmeScanConfigSetReqSerFree(void *msg);
 
-extern u8* CsrWifiSmeScanFullReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanFullReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeScanFullReqSizeof(void *msg);
+extern u8* CsrWifiSmeScanFullReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeScanFullReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeScanFullReqSizeof(void *msg);
 extern void CsrWifiSmeScanFullReqSerFree(void *msg);
 
 #define CsrWifiSmeScanResultsFlushReqSer CsrWifiEventSer
@@ -235,9 +235,9 @@ extern void CsrWifiSmeScanFullReqSerFree(void *msg);
 #define CsrWifiSmeSmeStaConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeSmeStaConfigGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeSmeStaConfigSetReqSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeStationMacAddressGetReqSer CsrWifiEventSer
@@ -245,9 +245,9 @@ extern CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeStationMacAddressGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeStationMacAddressGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeTspecReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeTspecReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeTspecReqSizeof(void *msg);
+extern u8* CsrWifiSmeTspecReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeTspecReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeTspecReqSizeof(void *msg);
 extern void CsrWifiSmeTspecReqSerFree(void *msg);
 
 #define CsrWifiSmeVersionsGetReqSer CsrWifiEventSer
@@ -255,9 +255,9 @@ extern void CsrWifiSmeTspecReqSerFree(void *msg);
 #define CsrWifiSmeVersionsGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeVersionsGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeWifiFlightmodeReqSizeof(void *msg);
+extern u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeWifiFlightmodeReqSizeof(void *msg);
 extern void CsrWifiSmeWifiFlightmodeReqSerFree(void *msg);
 
 #define CsrWifiSmeWifiOffReqSer CsrWifiEventSer
@@ -265,14 +265,14 @@ extern void CsrWifiSmeWifiFlightmodeReqSerFree(void *msg);
 #define CsrWifiSmeWifiOffReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeWifiOffReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWifiOnReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeWifiOnReqSizeof(void *msg);
+extern u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeWifiOnReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeWifiOnReqSizeof(void *msg);
 extern void CsrWifiSmeWifiOnReqSerFree(void *msg);
 
-extern u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg);
 extern void CsrWifiSmeCloakedSsidsSetReqSerFree(void *msg);
 
 #define CsrWifiSmeCloakedSsidsGetReqSer CsrWifiEventSer
@@ -285,9 +285,9 @@ extern void CsrWifiSmeCloakedSsidsSetReqSerFree(void *msg);
 #define CsrWifiSmeSmeCommonConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeSmeCommonConfigGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeSmeCommonConfigSetReqSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeInterfaceCapabilityGetReqSer CsrWifiEventSer
@@ -295,14 +295,14 @@ extern CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeInterfaceCapabilityGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeInterfaceCapabilityGetReqSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeWpsConfigurationReqSizeof(void *msg);
+extern u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeWpsConfigurationReqSizeof(void *msg);
 extern void CsrWifiSmeWpsConfigurationReqSerFree(void *msg);
 
-extern u8* CsrWifiSmeSetReqSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSetReqDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeSetReqSizeof(void *msg);
+extern u8* CsrWifiSmeSetReqSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeSetReqDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeSetReqSizeof(void *msg);
 extern void CsrWifiSmeSetReqSerFree(void *msg);
 
 #define CsrWifiSmeActivateCfmSer CsrWifiEventCsrUint16Ser
@@ -310,9 +310,9 @@ extern void CsrWifiSmeSetReqSerFree(void *msg);
 #define CsrWifiSmeActivateCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeActivateCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeAdhocConfigGetCfmSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeAdhocConfigSetCfmSer CsrWifiEventCsrUint16Ser
@@ -320,24 +320,24 @@ extern CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeAdhocConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeAdhocConfigSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg);
+extern u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeAssociationCompleteIndSizeof(void *msg);
 extern void CsrWifiSmeAssociationCompleteIndSerFree(void *msg);
 
-extern u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeAssociationStartIndSizeof(void *msg);
+extern u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeAssociationStartIndSizeof(void *msg);
 #define CsrWifiSmeAssociationStartIndSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeBlacklistCfmSizeof(void *msg);
+extern u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeBlacklistCfmSizeof(void *msg);
 extern void CsrWifiSmeBlacklistCfmSerFree(void *msg);
 
-extern u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg);
 extern void CsrWifiSmeCalibrationDataGetCfmSerFree(void *msg);
 
 #define CsrWifiSmeCalibrationDataSetCfmSer CsrWifiEventCsrUint16Ser
@@ -345,19 +345,19 @@ extern void CsrWifiSmeCalibrationDataGetCfmSerFree(void *msg);
 #define CsrWifiSmeCalibrationDataSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeCalibrationDataSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCcxConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCcxConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeCcxConfigGetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCcxConfigSetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCcxConfigSetCfmSizeof(void *msg);
 #define CsrWifiSmeCcxConfigSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCoexConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeCoexConfigGetCfmSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeCoexConfigSetCfmSer CsrWifiEventCsrUint16Ser
@@ -365,34 +365,34 @@ extern CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeCoexConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeCoexConfigSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCoexInfoGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCoexInfoGetCfmSizeof(void *msg);
 #define CsrWifiSmeCoexInfoGetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeConnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeConnectCfmSizeof(void *msg);
+extern u8* CsrWifiSmeConnectCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeConnectCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeConnectCfmSizeof(void *msg);
 #define CsrWifiSmeConnectCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg);
 extern void CsrWifiSmeConnectionConfigGetCfmSerFree(void *msg);
 
-extern u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg);
 extern void CsrWifiSmeConnectionInfoGetCfmSerFree(void *msg);
 
-extern u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeConnectionQualityIndSizeof(void *msg);
+extern u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeConnectionQualityIndSizeof(void *msg);
 #define CsrWifiSmeConnectionQualityIndSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg);
 #define CsrWifiSmeConnectionStatsGetCfmSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeDeactivateCfmSer CsrWifiEventCsrUint16Ser
@@ -400,9 +400,9 @@ extern CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg);
 #define CsrWifiSmeDeactivateCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeDeactivateCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg);
+extern u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeDisconnectCfmSizeof(void *msg);
 #define CsrWifiSmeDisconnectCfmSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeEventMaskSetCfmSer CsrWifiEventCsrUint16Ser
@@ -410,39 +410,39 @@ extern CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg);
 #define CsrWifiSmeEventMaskSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeEventMaskSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeHostConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeHostConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeHostConfigGetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeHostConfigSetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeHostConfigSetCfmSizeof(void *msg);
 #define CsrWifiSmeHostConfigSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeIbssStationIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeIbssStationIndSizeof(void *msg);
+extern u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeIbssStationIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeIbssStationIndSizeof(void *msg);
 #define CsrWifiSmeIbssStationIndSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeKeyCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeKeyCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeKeyCfmSizeof(void *msg);
+extern u8* CsrWifiSmeKeyCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeKeyCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeKeyCfmSizeof(void *msg);
 #define CsrWifiSmeKeyCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeLinkQualityGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeLinkQualityGetCfmSizeof(void *msg);
 #define CsrWifiSmeLinkQualityGetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg);
+extern u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMediaStatusIndSizeof(void *msg);
 extern void CsrWifiSmeMediaStatusIndSerFree(void *msg);
 
-extern u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMibConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeMibConfigGetCfmSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeMibConfigSetCfmSer CsrWifiEventCsrUint16Ser
@@ -450,14 +450,14 @@ extern CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeMibConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeMibConfigSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMibGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMibGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMibGetCfmSizeof(void *msg);
 extern void CsrWifiSmeMibGetCfmSerFree(void *msg);
 
-extern u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMibGetNextCfmSizeof(void *msg);
+extern u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMibGetNextCfmSizeof(void *msg);
 extern void CsrWifiSmeMibGetNextCfmSerFree(void *msg);
 
 #define CsrWifiSmeMibSetCfmSer CsrWifiEventCsrUint16Ser
@@ -465,39 +465,39 @@ extern void CsrWifiSmeMibGetNextCfmSerFree(void *msg);
 #define CsrWifiSmeMibSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeMibSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMicFailureIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMicFailureIndSizeof(void *msg);
+extern u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMicFailureIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMicFailureIndSizeof(void *msg);
 #define CsrWifiSmeMicFailureIndSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeMulticastAddressCfmSizeof(void *msg);
+extern u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeMulticastAddressCfmSizeof(void *msg);
 extern void CsrWifiSmeMulticastAddressCfmSerFree(void *msg);
 
-extern u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmePacketFilterSetCfmSizeof(void *msg);
+extern u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmePacketFilterSetCfmSizeof(void *msg);
 #define CsrWifiSmePacketFilterSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg);
 #define CsrWifiSmePermanentMacAddressGetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg);
+extern u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmePmkidCandidateListIndSizeof(void *msg);
 extern void CsrWifiSmePmkidCandidateListIndSerFree(void *msg);
 
-extern u8* CsrWifiSmePmkidCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePmkidCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmePmkidCfmSizeof(void *msg);
+extern u8* CsrWifiSmePmkidCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmePmkidCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmePmkidCfmSizeof(void *msg);
 extern void CsrWifiSmePmkidCfmSerFree(void *msg);
 
-extern u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmePowerConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmePowerConfigGetCfmSerFree CsrWifiSmePfree
 
 #define CsrWifiSmePowerConfigSetCfmSer CsrWifiEventCsrUint16Ser
@@ -505,34 +505,34 @@ extern CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmePowerConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmePowerConfigSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg);
 #define CsrWifiSmeRegulatoryDomainInfoGetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeRoamCompleteIndSizeof(void *msg);
+extern u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeRoamCompleteIndSizeof(void *msg);
 #define CsrWifiSmeRoamCompleteIndSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamStartIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeRoamStartIndSizeof(void *msg);
+extern u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeRoamStartIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeRoamStartIndSizeof(void *msg);
 #define CsrWifiSmeRoamStartIndSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeRoamingConfigGetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg);
 #define CsrWifiSmeRoamingConfigSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeScanConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeScanConfigGetCfmSizeof(void *msg);
 extern void CsrWifiSmeScanConfigGetCfmSerFree(void *msg);
 
 #define CsrWifiSmeScanConfigSetCfmSer CsrWifiEventCsrUint16Ser
@@ -545,9 +545,9 @@ extern void CsrWifiSmeScanConfigGetCfmSerFree(void *msg);
 #define CsrWifiSmeScanFullCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeScanFullCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeScanResultIndSizeof(void *msg);
+extern u8* CsrWifiSmeScanResultIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeScanResultIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeScanResultIndSizeof(void *msg);
 extern void CsrWifiSmeScanResultIndSerFree(void *msg);
 
 #define CsrWifiSmeScanResultsFlushCfmSer CsrWifiEventCsrUint16Ser
@@ -555,39 +555,39 @@ extern void CsrWifiSmeScanResultIndSerFree(void *msg);
 #define CsrWifiSmeScanResultsFlushCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeScanResultsFlushCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeScanResultsGetCfmSizeof(void *msg);
 extern void CsrWifiSmeScanResultsGetCfmSerFree(void *msg);
 
-extern u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeSmeStaConfigGetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg);
 #define CsrWifiSmeSmeStaConfigSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg);
 #define CsrWifiSmeStationMacAddressGetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeTspecIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeTspecIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeTspecIndSizeof(void *msg);
+extern u8* CsrWifiSmeTspecIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeTspecIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeTspecIndSizeof(void *msg);
 extern void CsrWifiSmeTspecIndSerFree(void *msg);
 
-extern u8* CsrWifiSmeTspecCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeTspecCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeTspecCfmSizeof(void *msg);
+extern u8* CsrWifiSmeTspecCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeTspecCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeTspecCfmSizeof(void *msg);
 extern void CsrWifiSmeTspecCfmSerFree(void *msg);
 
-extern u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeVersionsGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeVersionsGetCfmSizeof(void *msg);
 extern void CsrWifiSmeVersionsGetCfmSerFree(void *msg);
 
 #define CsrWifiSmeWifiFlightmodeCfmSer CsrWifiEventCsrUint16Ser
@@ -615,19 +615,19 @@ extern void CsrWifiSmeVersionsGetCfmSerFree(void *msg);
 #define CsrWifiSmeCloakedSsidsSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeCloakedSsidsSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg);
 extern void CsrWifiSmeCloakedSsidsGetCfmSerFree(void *msg);
 
-extern u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWifiOnIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeWifiOnIndSizeof(void *msg);
+extern u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeWifiOnIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeWifiOnIndSizeof(void *msg);
 #define CsrWifiSmeWifiOnIndSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeSmeCommonConfigGetCfmSerFree CsrWifiSmePfree
 
 #define CsrWifiSmeSmeCommonConfigSetCfmSer CsrWifiEventCsrUint16Ser
@@ -635,24 +635,24 @@ extern CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeSmeCommonConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeSmeCommonConfigSetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg);
+extern u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg);
 #define CsrWifiSmeInterfaceCapabilityGetCfmSerFree CsrWifiSmePfree
 
-extern u8* CsrWifiSmeErrorIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeErrorIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeErrorIndSizeof(void *msg);
+extern u8* CsrWifiSmeErrorIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeErrorIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeErrorIndSizeof(void *msg);
 extern void CsrWifiSmeErrorIndSerFree(void *msg);
 
-extern u8* CsrWifiSmeInfoIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeInfoIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeInfoIndSizeof(void *msg);
+extern u8* CsrWifiSmeInfoIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeInfoIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeInfoIndSizeof(void *msg);
 extern void CsrWifiSmeInfoIndSerFree(void *msg);
 
-extern u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, CsrSize len);
-extern CsrSize CsrWifiSmeCoreDumpIndSizeof(void *msg);
+extern u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, size_t *len, void *msg);
+extern void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, size_t len);
+extern size_t CsrWifiSmeCoreDumpIndSizeof(void *msg);
 extern void CsrWifiSmeCoreDumpIndSerFree(void *msg);
 
 #define CsrWifiSmeAmpStatusChangeIndSer CsrWifiEventCsrUint16CsrUint8Ser

drivers/staging/csr/sme_userspace.h

@@ -32,7 +32,7 @@ int uf_sme_queue_message(unifi_priv_t *priv, u8 *buffer, int length);
 #include "csr_wifi_sme_lib.h"
 
 void CsrWifiRouterTransportInit(unifi_priv_t *priv);
-void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLength);
+void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, size_t bufferLength);
 void CsrWifiRouterTransportDeInit(unifi_priv_t *priv);
 
 #endif /* __LINUX_SME_USERSPACE_H__ */