staging: csr: remove CsrUint16 typedef

Use the in-kernel u16 type instead.

Cc: Mikko Virkkilä <mikko.virkkila@bluegiga.com>
Cc: Lauri Hintsala <Lauri.Hintsala@bluegiga.com>
Cc: Riku Mettälä <riku.mettala@bluegiga.com>
Cc: Veli-Pekka Peltola <veli-pekka.peltola@bluegiga.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

104 files changed, 2804 insertions, 2805 deletions

diff --git a/drivers/staging/csr/csr_framework_ext.c b/drivers/staging/csr/csr_framework_ext.c
index 1586b235e29..b2b2ea9e53d 100644
--- a/drivers/staging/csr/csr_framework_ext.c
+++ b/drivers/staging/csr/csr_framework_ext.c
@@ -138,7 +138,7 @@ CsrResult CsrMutexUnlock(CsrMutexHandle *mutexHandle)
  *      void
  *
  *----------------------------------------------------------------------------*/
-void CsrThreadSleep(CsrUint16 sleepTimeInMs)
+void CsrThreadSleep(u16 sleepTimeInMs)
 {
     unsigned long t;
 
diff --git a/drivers/staging/csr/csr_framework_ext.h b/drivers/staging/csr/csr_framework_ext.h
index 401bf2d547a..942db87faa0 100644
--- a/drivers/staging/csr/csr_framework_ext.h
+++ b/drivers/staging/csr/csr_framework_ext.h
@@ -27,13 +27,13 @@ extern "C" {
 #define CSR_FE_RESULT_NO_MORE_THREADS   ((CsrResult) 0x0006)
 
 /* Thread priorities */
-#define CSR_THREAD_PRIORITY_HIGHEST     ((CsrUint16) 0)
-#define CSR_THREAD_PRIORITY_HIGH        ((CsrUint16) 1)
-#define CSR_THREAD_PRIORITY_NORMAL      ((CsrUint16) 2)
-#define CSR_THREAD_PRIORITY_LOW         ((CsrUint16) 3)
-#define CSR_THREAD_PRIORITY_LOWEST      ((CsrUint16) 4)
+#define CSR_THREAD_PRIORITY_HIGHEST     ((u16) 0)
+#define CSR_THREAD_PRIORITY_HIGH        ((u16) 1)
+#define CSR_THREAD_PRIORITY_NORMAL      ((u16) 2)
+#define CSR_THREAD_PRIORITY_LOW         ((u16) 3)
+#define CSR_THREAD_PRIORITY_LOWEST      ((u16) 4)
 
-#define CSR_EVENT_WAIT_INFINITE         ((CsrUint16) 0xFFFF)
+#define CSR_EVENT_WAIT_INFINITE         ((u16) 0xFFFF)
 
 /*----------------------------------------------------------------------------*
  *  NAME
@@ -66,7 +66,7 @@ CsrResult CsrEventCreate(CsrEventHandle *eventHandle);
  *          CSR_FE_RESULT_INVALID_POINTER      in case the eventBits pointer is invalid
  *
  *----------------------------------------------------------------------------*/
-CsrResult CsrEventWait(CsrEventHandle *eventHandle, CsrUint16 timeoutInMs, CsrUint32 *eventBits);
+CsrResult CsrEventWait(CsrEventHandle *eventHandle, u16 timeoutInMs, CsrUint32 *eventBits);
 
 /*----------------------------------------------------------------------------*
  *  NAME
@@ -195,7 +195,7 @@ void CsrGlobalMutexUnlock(void);
  *
  *----------------------------------------------------------------------------*/
 CsrResult CsrThreadCreate(void (*threadFunction)(void *pointer), void *pointer,
-    CsrUint32 stackSize, CsrUint16 priority,
+    CsrUint32 stackSize, u16 priority,
     const CsrCharString *threadName, CsrThreadHandle *threadHandle);
 
 /*----------------------------------------------------------------------------*
@@ -240,7 +240,7 @@ CsrResult CsrThreadEqual(CsrThreadHandle *threadHandle1, CsrThreadHandle *thread
  *      void
  *
  *----------------------------------------------------------------------------*/
-void CsrThreadSleep(CsrUint16 sleepTimeInMs);
+void CsrThreadSleep(u16 sleepTimeInMs);
 
 #ifndef CSR_PMEM_DEBUG_ENABLE
 /*----------------------------------------------------------------------------*
diff --git a/drivers/staging/csr/csr_lib.h b/drivers/staging/csr/csr_lib.h
index 041bd0950b3..7259b63f17a 100644
--- a/drivers/staging/csr/csr_lib.h
+++ b/drivers/staging/csr/csr_lib.h
@@ -30,7 +30,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEvent
  *
  *----------------------------------------------------------------------------*/
-CsrEvent *CsrEvent_struct(CsrUint16 primtype, CsrUint16 msgtype);
+CsrEvent *CsrEvent_struct(u16 primtype, u16 msgtype);
 
 typedef struct
 {
@@ -46,12 +46,12 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint8
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint8 *CsrEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, u8 value);
+CsrEventCsrUint8 *CsrEventCsrUint8_struct(u16 primtype, u16 msgtype, u8 value);
 
 typedef struct
 {
     CsrPrim   type;
-    CsrUint16 value;
+    u16 value;
 } CsrEventCsrUint16;
 
 /*----------------------------------------------------------------------------*
@@ -62,12 +62,12 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint16
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint16 *CsrEventCsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value);
+CsrEventCsrUint16 *CsrEventCsrUint16_struct(u16 primtype, u16 msgtype, u16 value);
 
 typedef struct
 {
     CsrPrim   type;
-    CsrUint16 value1;
+    u16 value1;
     u8  value2;
 } CsrEventCsrUint16CsrUint8;
 
@@ -79,13 +79,13 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint16CsrUint8
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrUint8 *CsrEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, u8 value2);
+CsrEventCsrUint16CsrUint8 *CsrEventCsrUint16CsrUint8_struct(u16 primtype, u16 msgtype, u16 value1, u8 value2);
 
 typedef struct
 {
     CsrPrim   type;
-    CsrUint16 value1;
-    CsrUint16 value2;
+    u16 value1;
+    u16 value2;
 } CsrEventCsrUint16CsrUint16;
 
 /*----------------------------------------------------------------------------*
@@ -96,12 +96,12 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint16CsrUint16
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrUint16 *CsrEventCsrUint16CsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrUint16 value2);
+CsrEventCsrUint16CsrUint16 *CsrEventCsrUint16CsrUint16_struct(u16 primtype, u16 msgtype, u16 value1, u16 value2);
 
 typedef struct
 {
     CsrPrim   type;
-    CsrUint16 value1;
+    u16 value1;
     CsrUint32 value2;
 } CsrEventCsrUint16CsrUint32;
 
@@ -113,12 +113,12 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint16
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrUint32 *CsrEventCsrUint16CsrUint32_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrUint32 value2);
+CsrEventCsrUint16CsrUint32 *CsrEventCsrUint16CsrUint32_struct(u16 primtype, u16 msgtype, u16 value1, CsrUint32 value2);
 
 typedef struct
 {
     CsrPrim        type;
-    CsrUint16      value1;
+    u16      value1;
     CsrCharString *value2;
 } CsrEventCsrUint16CsrCharString;
 
@@ -130,7 +130,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint16CsrCharString
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrCharString *CsrEventCsrUint16CsrCharString_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrCharString *value2);
+CsrEventCsrUint16CsrCharString *CsrEventCsrUint16CsrCharString_struct(u16 primtype, u16 msgtype, u16 value1, CsrCharString *value2);
 
 typedef struct
 {
@@ -146,13 +146,13 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint32
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint32 *CsrEventCsrUint32_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint32 value);
+CsrEventCsrUint32 *CsrEventCsrUint32_struct(u16 primtype, u16 msgtype, CsrUint32 value);
 
 typedef struct
 {
     CsrPrim   type;
     CsrUint32 value1;
-    CsrUint16 value2;
+    u16 value2;
 } CsrEventCsrUint32CsrUint16;
 
 /*----------------------------------------------------------------------------*
@@ -163,7 +163,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint32CsrUint16
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint32CsrUint16 *CsrEventCsrUint32CsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint32 value1, CsrUint32 value2);
+CsrEventCsrUint32CsrUint16 *CsrEventCsrUint32CsrUint16_struct(u16 primtype, u16 msgtype, CsrUint32 value1, CsrUint32 value2);
 
 typedef struct
 {
@@ -180,7 +180,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint32CsrCharString
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint32CsrCharString *CsrEventCsrUint32CsrCharString_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint32 value1, CsrCharString *value2);
+CsrEventCsrUint32CsrCharString *CsrEventCsrUint32CsrCharString_struct(u16 primtype, u16 msgtype, CsrUint32 value1, CsrCharString *value2);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_log.h b/drivers/staging/csr/csr_log.h
index f86c4920628..f6aaac18f99 100644
--- a/drivers/staging/csr/csr_log.h
+++ b/drivers/staging/csr/csr_log.h
@@ -96,7 +96,7 @@ CsrBool CsrLogTaskIsFiltered(CsrSchedQid taskId, CsrLogLevelTask level);
 
 typedef struct
 {
-    CsrUint16            primitiveType;
+    u16            primitiveType;
     const CsrCharString *primitiveName;
     CsrMsgConvMsgEntry  *messageConv; /* Private - do not use */
 } CsrLogPrimitiveInformation;
@@ -112,7 +112,7 @@ typedef struct
 /*  Tech logging */
 /*---------------------------------*/
 typedef u8 bitmask8_t;
-typedef CsrUint16 bitmask16_t;
+typedef u16 bitmask16_t;
 typedef CsrUint32 bitmask32_t;
 
 #ifdef CSR_LOG_ENABLE
@@ -175,7 +175,7 @@ void CsrLogSchedStart(u8 thread_id);
 void CsrLogSchedStop(u8 thread_id);
 
 void CsrLogInitTask(u8 thread_id, CsrSchedQid tskid, const CsrCharString *tskName);
-void CsrLogDeinitTask(CsrUint16 task_id);
+void CsrLogDeinitTask(u16 task_id);
 
 void CsrLogActivate(CsrSchedQid tskid);
 void CsrLogDeactivate(CsrSchedQid tskid);
@@ -188,14 +188,14 @@ void CsrLogMessagePut(CsrUint32 line,
     CsrSchedQid src_task_id,
     CsrSchedQid dst_taskid,
     CsrSchedMsgId msg_id,
-    CsrUint16 prim_type,
+    u16 prim_type,
     const void *msg);
 
 void CsrLogMessageGet(CsrSchedQid src_task_id,
     CsrSchedQid dst_taskid,
     CsrBool get_res,
     CsrSchedMsgId msg_id,
-    CsrUint16 prim_type,
+    u16 prim_type,
     const void *msg);
 
 void CsrLogTimedEventIn(CsrUint32 line,
@@ -203,7 +203,7 @@ void CsrLogTimedEventIn(CsrUint32 line,
     CsrSchedQid task_id,
     CsrSchedTid tid,
     CsrTime requested_delay,
-    CsrUint16 fniarg,
+    u16 fniarg,
     const void *fnvarg);
 
 void CsrLogTimedEventFire(CsrSchedQid task_id,
@@ -227,18 +227,18 @@ void CsrLogBgintSet(CsrSchedBgint irq);
 void CsrLogBgintServiceStart(CsrSchedBgint irq);
 void CsrLogBgintServiceDone(CsrSchedBgint irq);
 
-void CsrLogExceptionStateEvent(CsrUint16 prim_type,
+void CsrLogExceptionStateEvent(u16 prim_type,
     CsrPrim msg_type,
-    CsrUint16 state,
+    u16 state,
     CsrUint32 line,
     const CsrCharString *file);
-void CsrLogExceptionGeneral(CsrUint16 prim_type,
-    CsrUint16 state,
+void CsrLogExceptionGeneral(u16 prim_type,
+    u16 state,
     const CsrCharString *text,
     CsrUint32 line,
     const CsrCharString *file);
-void CsrLogExceptionWarning(CsrUint16 prim_type,
-    CsrUint16 state,
+void CsrLogExceptionWarning(u16 prim_type,
+    u16 state,
     const CsrCharString *text,
     CsrUint32 line,
     const CsrCharString *file);
diff --git a/drivers/staging/csr/csr_log_configure.h b/drivers/staging/csr/csr_log_configure.h
index 8c727adce76..c47016ba833 100644
--- a/drivers/staging/csr/csr_log_configure.h
+++ b/drivers/staging/csr/csr_log_configure.h
@@ -57,7 +57,7 @@ typedef CsrUint32 CsrLogLevelText;
 #define CSR_LOG_LEVEL_TEXT_ALL       ((CsrLogLevelText) 0xFFFF)
 
 /* The log text interface is used by both scheduler tasks and components outside the scheduler context.
- * Therefore a CsrLogTextTaskId is introduced. It is effectively considered as two CsrUint16's. The lower
+ * Therefore a CsrLogTextTaskId is introduced. It is effectively considered as two u16's. The lower
  * 16 bits corresponds one2one with the scheduler queueId's (CsrSchedQid) and as such these bits can not be used
  * by components outside scheduler tasks. The upper 16 bits are allocated for use of components outside the
  * scheduler like drivers etc. Components in this range is defined independently by each technology. To avoid
@@ -78,7 +78,7 @@ void CsrLogLevelTextSetTask(CsrLogTextTaskId taskId, CsrLogLevelText warningLeve
 /* Set the text logging level for a given tasks subOrigin */
 /* This function can be used as a complement to CsrLogLevelTextSetAll() and CsrLogLevelTextSetTask() to add more _or_ less log from a given
  * subOrigin within a task than what is set generally with CsrLogLevelTextSetAll() _or_ CsrLogLevelTextSetTask(). */
-void CsrLogLevelTextSetTaskSubOrigin(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrLogLevelText warningLevelMask);
+void CsrLogLevelTextSetTaskSubOrigin(CsrLogTextTaskId taskId, u16 subOrigin, CsrLogLevelText warningLevelMask);
 
 /*******************************************************************************
 
diff --git a/drivers/staging/csr/csr_log_text.h b/drivers/staging/csr/csr_log_text.h
index 6e0df43c008..cb01655aed6 100644
--- a/drivers/staging/csr/csr_log_text.h
+++ b/drivers/staging/csr/csr_log_text.h
@@ -19,13 +19,13 @@ extern "C" {
 
 typedef struct CsrLogSubOrigin
 {
-    CsrUint16            subOriginNumber;  /* Id of the given SubOrigin */
+    u16            subOriginNumber;  /* Id of the given SubOrigin */
     const CsrCharString *subOriginName;    /* Prefix Text for this SubOrigin */
 } CsrLogSubOrigin;
 
 /* Register a task which is going to use the CSR_LOG_TEXT_XXX interface */
 #ifdef CSR_LOG_ENABLE
-void CsrLogTextRegister(CsrLogTextTaskId taskId, const CsrCharString *taskName, CsrUint16 subOriginsLength, const CsrLogSubOrigin *subOrigins);
+void CsrLogTextRegister(CsrLogTextTaskId taskId, const CsrCharString *taskName, u16 subOriginsLength, const CsrLogSubOrigin *subOrigins);
 #else
 #define CsrLogTextRegister(taskId, taskName, subOriginsLength, subOrigins)
 #endif
@@ -33,8 +33,8 @@ void CsrLogTextRegister(CsrLogTextTaskId taskId, const CsrCharString *taskName,
 /* CRITICAL: Conditions that are threatening to the integrity/stability of the
    system as a whole. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_CRITICAL_DISABLE)
-void CsrLogTextCritical(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextCritical(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
 #define CSR_LOG_TEXT_CRITICAL(taskId_subOrigin_formatString_varargs) CsrLogTextCritical taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_CRITICAL(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_CRITICAL(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_CRITICAL(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferCritical taskId_subOrigin_length_buffer_formatString_varargs
@@ -49,8 +49,8 @@ void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrS
 /* ERROR: Malfunction of a component rendering it unable to operate correctly,
    causing lack of functionality but not loss of system integrity/stability. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_ERROR_DISABLE)
-void CsrLogTextError(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferError(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextError(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
 #define CSR_LOG_TEXT_ERROR(taskId_subOrigin_formatString_varargs) CsrLogTextError taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_ERROR(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_ERROR(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_ERROR(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferError taskId_subOrigin_length_buffer_formatString_varargs
@@ -66,8 +66,8 @@ void CsrLogTextBufferError(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize
    or violations of specifications, where the result of such deviations does not
    lead to malfunction of the component. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_WARNING_DISABLE)
-void CsrLogTextWarning(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextWarning(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
 #define CSR_LOG_TEXT_WARNING(taskId_subOrigin_formatString_varargs) CsrLogTextWarning taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_WARNING(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_WARNING(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_WARNING(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferWarning taskId_subOrigin_length_buffer_formatString_varargs
@@ -82,8 +82,8 @@ void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSi
 /* INFO: Important events that may aid in determining the conditions under which
    the more severe conditions are encountered. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_INFO_DISABLE)
-void CsrLogTextInfo(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextInfo(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
 #define CSR_LOG_TEXT_INFO(taskId_subOrigin_formatString_varargs) CsrLogTextInfo taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_INFO(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_INFO(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_INFO(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferInfo taskId_subOrigin_length_buffer_formatString_varargs
@@ -97,8 +97,8 @@ void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize
 
 /* DEBUG: Similar to INFO, but dedicated to events that occur more frequently. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_DEBUG_DISABLE)
-void CsrLogTextDebug(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextDebug(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
 #define CSR_LOG_TEXT_DEBUG(taskId_subOrigin_formatString_varargs) CsrLogTextDebug taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_DEBUG(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_DEBUG(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_DEBUG(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferDebug taskId_subOrigin_length_buffer_formatString_varargs
diff --git a/drivers/staging/csr/csr_macro.h b/drivers/staging/csr/csr_macro.h
index e8de0a7bab9..7656e2ac5d5 100644
--- a/drivers/staging/csr/csr_macro.h
+++ b/drivers/staging/csr/csr_macro.h
@@ -31,7 +31,7 @@ extern "C" {
 /*------------------------------------------------------------------*/
 /* Endian conversion */
 /*------------------------------------------------------------------*/
-#define CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr)        (((CsrUint16) ((u8 *) (ptr))[0]) | ((CsrUint16) ((u8 *) (ptr))[1]) << 8)
+#define CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr)        (((u16) ((u8 *) (ptr))[0]) | ((u16) ((u8 *) (ptr))[1]) << 8)
 #define CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr)        (((CsrUint32) ((u8 *) (ptr))[0]) | ((CsrUint32) ((u8 *) (ptr))[1]) << 8 | \
                                                        ((CsrUint32) ((u8 *) (ptr))[2]) << 16 | ((CsrUint32) ((u8 *) (ptr))[3]) << 24)
 #define CSR_COPY_UINT16_TO_LITTLE_ENDIAN(uint, ptr)    ((u8 *) (ptr))[0] = ((u8) ((uint) & 0x00FF)); \
@@ -40,7 +40,7 @@ extern "C" {
     ((u8 *) (ptr))[1] = ((u8) (((uint) >> 8) & 0x000000FF)); \
     ((u8 *) (ptr))[2] = ((u8) (((uint) >> 16) & 0x000000FF)); \
     ((u8 *) (ptr))[3] = ((u8) (((uint) >> 24) & 0x000000FF))
-#define CSR_GET_UINT16_FROM_BIG_ENDIAN(ptr) (((CsrUint16) ((u8 *) (ptr))[1]) | ((CsrUint16) ((u8 *) (ptr))[0]) << 8)
+#define CSR_GET_UINT16_FROM_BIG_ENDIAN(ptr) (((u16) ((u8 *) (ptr))[1]) | ((u16) ((u8 *) (ptr))[0]) << 8)
 #define CSR_GET_UINT24_FROM_BIG_ENDIAN(ptr) (((CsrUint24) ((u8 *) (ptr))[2]) | \
                                              ((CsrUint24) ((u8 *) (ptr))[1]) << 8 | ((CsrUint24) ((u8 *) (ptr))[0]) << 16)
 #define CSR_GET_UINT32_FROM_BIG_ENDIAN(ptr) (((CsrUint32) ((u8 *) (ptr))[3]) | ((CsrUint32) ((u8 *) (ptr))[2]) << 8 | \
@@ -66,8 +66,8 @@ extern "C" {
     (output) = ((u8) (input));(input) += 2
 
 #define CSR_CONVERT_16_FROM_XAP(output, input) \
-    (output) = (CsrUint16) ((((CsrUint16) (input)[1]) << 8) | \
-                            ((CsrUint16) (input)[0]));(input) += 2
+    (output) = (u16) ((((u16) (input)[1]) << 8) | \
+                            ((u16) (input)[0]));(input) += 2
 
 #define CSR_CONVERT_32_FROM_XAP(output, input) \
     (output) = (((CsrUint32) (input)[1]) << 24) | \
diff --git a/drivers/staging/csr/csr_msgconv.c b/drivers/staging/csr/csr_msgconv.c
index 3f57b042c8f..b2aeb7a184c 100644
--- a/drivers/staging/csr/csr_msgconv.c
+++ b/drivers/staging/csr/csr_msgconv.c
@@ -18,7 +18,7 @@
 
 static CsrMsgConvEntry *converter;
 
-CsrMsgConvPrimEntry *CsrMsgConvFind(CsrUint16 primType)
+CsrMsgConvPrimEntry *CsrMsgConvFind(u16 primType)
 {
     CsrMsgConvPrimEntry *ptr = NULL;
 
@@ -41,7 +41,7 @@ CsrMsgConvPrimEntry *CsrMsgConvFind(CsrUint16 primType)
     return ptr;
 }
 
-static const CsrMsgConvMsgEntry *find_msg_converter(CsrMsgConvPrimEntry *ptr, CsrUint16 msgType)
+static const CsrMsgConvMsgEntry *find_msg_converter(CsrMsgConvPrimEntry *ptr, u16 msgType)
 {
     const CsrMsgConvMsgEntry *cv = ptr->conv;
     if (ptr->lookupFunc)
@@ -71,7 +71,7 @@ static const CsrMsgConvMsgEntry *find_msg_converter(CsrMsgConvPrimEntry *ptr, Cs
     return cv;
 }
 
-static void *deserialize_data(CsrUint16 primType,
+static void *deserialize_data(u16 primType,
     CsrSize length,
     u8 *data)
 {
@@ -83,7 +83,7 @@ static void *deserialize_data(CsrUint16 primType,
     if (ptr)
     {
         const CsrMsgConvMsgEntry *cv;
-        CsrUint16 msgId = 0;
+        u16 msgId = 0;
         CsrSize offset = 0;
         CsrUint16Des(&msgId, data, &offset);
 
@@ -105,7 +105,7 @@ static void *deserialize_data(CsrUint16 primType,
     return ret;
 }
 
-static CsrSize sizeof_message(CsrUint16 primType, void *msg)
+static CsrSize sizeof_message(u16 primType, void *msg)
 {
     CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
     CsrSize ret;
@@ -113,7 +113,7 @@ static CsrSize sizeof_message(CsrUint16 primType, void *msg)
     if (ptr)
     {
         const CsrMsgConvMsgEntry *cv;
-        CsrUint16 msgId = *(CsrUint16 *) msg;
+        u16 msgId = *(u16 *) msg;
 
         cv = find_msg_converter(ptr, msgId);
         if (cv)
@@ -133,7 +133,7 @@ static CsrSize sizeof_message(CsrUint16 primType, void *msg)
     return ret;
 }
 
-static CsrBool free_message(CsrUint16 primType, u8 *data)
+static CsrBool free_message(u16 primType, u8 *data)
 {
     CsrMsgConvPrimEntry *ptr;
     CsrBool ret;
@@ -143,7 +143,7 @@ static CsrBool free_message(CsrUint16 primType, u8 *data)
     if (ptr)
     {
         const CsrMsgConvMsgEntry *cv;
-        CsrUint16 msgId = *(CsrUint16 *) data;
+        u16 msgId = *(u16 *) data;
 
         cv = find_msg_converter(ptr, msgId);
         if (cv)
@@ -164,7 +164,7 @@ static CsrBool free_message(CsrUint16 primType, u8 *data)
     return ret;
 }
 
-static u8 *serialize_message(CsrUint16 primType,
+static u8 *serialize_message(u16 primType,
     void *msg,
     CsrSize *length,
     u8 *buffer)
@@ -180,7 +180,7 @@ static u8 *serialize_message(CsrUint16 primType,
     {
         const CsrMsgConvMsgEntry *cv;
 
-        cv = find_msg_converter(ptr, *(CsrUint16 *) msg);
+        cv = find_msg_converter(ptr, *(u16 *) msg);
         if (cv)
         {
             ret = cv->serFunc(buffer, length, msg);
@@ -198,12 +198,12 @@ static u8 *serialize_message(CsrUint16 primType,
     return ret;
 }
 
-CsrSize CsrMsgConvSizeof(CsrUint16 primType, void *msg)
+CsrSize CsrMsgConvSizeof(u16 primType, void *msg)
 {
     return sizeof_message(primType, msg);
 }
 
-u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg)
+u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, u16 primType, void *msg)
 {
     if (converter)
     {
@@ -221,7 +221,7 @@ u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, Cs
 }
 
 /* Insert profile converter at head of converter list. */
-void CsrMsgConvInsert(CsrUint16 primType, const CsrMsgConvMsgEntry *ce)
+void CsrMsgConvInsert(u16 primType, const CsrMsgConvMsgEntry *ce)
 {
     CsrMsgConvPrimEntry *pc;
     pc = CsrMsgConvFind(primType);
@@ -242,7 +242,7 @@ void CsrMsgConvInsert(CsrUint16 primType, const CsrMsgConvMsgEntry *ce)
 }
 EXPORT_SYMBOL_GPL(CsrMsgConvInsert);
 
-CsrMsgConvMsgEntry *CsrMsgConvFindEntry(CsrUint16 primType, CsrUint16 msgType)
+CsrMsgConvMsgEntry *CsrMsgConvFindEntry(u16 primType, u16 msgType)
 {
     CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
     if (ptr)
@@ -253,18 +253,18 @@ CsrMsgConvMsgEntry *CsrMsgConvFindEntry(CsrUint16 primType, CsrUint16 msgType)
 }
 EXPORT_SYMBOL_GPL(CsrMsgConvFindEntry);
 
-CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(CsrUint16 primType, const void *msg)
+CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(u16 primType, const void *msg)
 {
     CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
     if (ptr && msg)
     {
-        CsrUint16 msgType = *((CsrUint16 *) msg);
+        u16 msgType = *((u16 *) msg);
         return (CsrMsgConvMsgEntry *) find_msg_converter(ptr, msgType);
     }
     return NULL;
 }
 
-void CsrMsgConvCustomLookupRegister(CsrUint16 primType, CsrMsgCustomLookupFunc *lookupFunc)
+void CsrMsgConvCustomLookupRegister(u16 primType, CsrMsgCustomLookupFunc *lookupFunc)
 {
     CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
     if (ptr)
diff --git a/drivers/staging/csr/csr_msgconv.h b/drivers/staging/csr/csr_msgconv.h
index dd4853d5ce6..7438f9578f0 100644
--- a/drivers/staging/csr/csr_msgconv.h
+++ b/drivers/staging/csr/csr_msgconv.h
@@ -28,7 +28,7 @@ typedef void *(CsrMsgDeserializeFunc)(u8 *buffer, CsrSize length);
 /* Converter entry for one message type */
 typedef struct CsrMsgConvMsgEntry
 {
-    CsrUint16              msgType;
+    u16              msgType;
     CsrMsgSizeofFunc      *sizeofFunc;
     CsrMsgSerializeFunc   *serFunc;
     CsrMsgDeserializeFunc *deserFunc;
@@ -36,12 +36,12 @@ typedef struct CsrMsgConvMsgEntry
 } CsrMsgConvMsgEntry;
 
 /* Optional lookup function */
-typedef CsrMsgConvMsgEntry *(CsrMsgCustomLookupFunc)(CsrMsgConvMsgEntry *ce, CsrUint16 msgType);
+typedef CsrMsgConvMsgEntry *(CsrMsgCustomLookupFunc)(CsrMsgConvMsgEntry *ce, u16 msgType);
 
 /* All converter entries for one specific primitive */
 typedef struct CsrMsgConvPrimEntry
 {
-    CsrUint16                   primType;
+    u16                   primType;
     const CsrMsgConvMsgEntry   *conv;
     CsrMsgCustomLookupFunc     *lookupFunc;
     struct CsrMsgConvPrimEntry *next;
@@ -50,21 +50,21 @@ typedef struct CsrMsgConvPrimEntry
 typedef struct
 {
     CsrMsgConvPrimEntry *profile_converters;
-    void *(*deserialize_data)(CsrUint16 primType, CsrSize length, u8 * data);
-    CsrBool (*free_message)(CsrUint16 primType, u8 *data);
-    CsrSize (*sizeof_message)(CsrUint16 primType, void *msg);
-    u8 *(*serialize_message)(CsrUint16 primType, void *msg,
+    void *(*deserialize_data)(u16 primType, CsrSize length, u8 * data);
+    CsrBool (*free_message)(u16 primType, u8 *data);
+    CsrSize (*sizeof_message)(u16 primType, void *msg);
+    u8 *(*serialize_message)(u16 primType, void *msg,
                                    CsrSize * length,
                                    u8 * buffer);
 } CsrMsgConvEntry;
 
-CsrSize CsrMsgConvSizeof(CsrUint16 primType, void *msg);
-u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg);
-void CsrMsgConvCustomLookupRegister(CsrUint16 primType, CsrMsgCustomLookupFunc *lookupFunc);
-void CsrMsgConvInsert(CsrUint16 primType, const CsrMsgConvMsgEntry *ce);
-CsrMsgConvPrimEntry *CsrMsgConvFind(CsrUint16 primType);
-CsrMsgConvMsgEntry *CsrMsgConvFindEntry(CsrUint16 primType, CsrUint16 msgType);
-CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(CsrUint16 primType, const void *msg);
+CsrSize CsrMsgConvSizeof(u16 primType, void *msg);
+u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, u16 primType, void *msg);
+void CsrMsgConvCustomLookupRegister(u16 primType, CsrMsgCustomLookupFunc *lookupFunc);
+void CsrMsgConvInsert(u16 primType, const CsrMsgConvMsgEntry *ce);
+CsrMsgConvPrimEntry *CsrMsgConvFind(u16 primType);
+CsrMsgConvMsgEntry *CsrMsgConvFindEntry(u16 primType, u16 msgType);
+CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(u16 primType, const void *msg);
 CsrMsgConvEntry *CsrMsgConvGet(void);
 CsrMsgConvEntry *CsrMsgConvInit(void);
 #ifdef ENABLE_SHUTDOWN
@@ -79,7 +79,7 @@ CsrUint32 CsrUtf16StringSerLen(const CsrUtf16String *str);
 
 /* Prototypes for primitive type serializers */
 void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value);
-void CsrUint16Ser(u8 *buffer, CsrSize *offset, CsrUint16 value);
+void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value);
 void CsrUint32Ser(u8 *buffer, CsrSize *offset, CsrUint32 value);
 void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length);
 void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value);
@@ -89,7 +89,7 @@ void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr);
 void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value);
 
 void CsrUint8Des(u8 *value, u8 *buffer, CsrSize *offset);
-void CsrUint16Des(CsrUint16 *value, u8 *buffer, CsrSize *offset);
+void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset);
 void CsrUint32Des(CsrUint32 *value, u8 *buffer, CsrSize *offset);
 void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length);
 void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset);
diff --git a/drivers/staging/csr/csr_panic.c b/drivers/staging/csr/csr_panic.c
index 87c72ad50f8..0b78a725cee 100644
--- a/drivers/staging/csr/csr_panic.c
+++ b/drivers/staging/csr/csr_panic.c
@@ -15,7 +15,7 @@
 #include "csr_types.h"
 #include "csr_panic.h"
 
-void CsrPanic(u8 tech, CsrUint16 reason, const char *p)
+void CsrPanic(u8 tech, u16 reason, const char *p)
 {
     BUG_ON(1);
 }
diff --git a/drivers/staging/csr/csr_panic.h b/drivers/staging/csr/csr_panic.h
index 2b7166873e8..e993baf5058 100644
--- a/drivers/staging/csr/csr_panic.h
+++ b/drivers/staging/csr/csr_panic.h
@@ -46,7 +46,7 @@ extern "C" {
 
 /* Panic interface used by technologies */
 /* DEPRECATED - replaced by csr_log_text.h */
-void CsrPanic(u8 tech, CsrUint16 reason, const char *p);
+void CsrPanic(u8 tech, u16 reason, const char *p);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_prim_defs.h b/drivers/staging/csr/csr_prim_defs.h
index 02ab9139194..7d47578f18e 100644
--- a/drivers/staging/csr/csr_prim_defs.h
+++ b/drivers/staging/csr/csr_prim_defs.h
@@ -18,44 +18,44 @@ extern "C" {
 /************************************************************************************
  * Segmentation of primitives in upstream and downstream segment
  ************************************************************************************/
-typedef CsrUint16 CsrPrim;
+typedef u16 CsrPrim;
 #define CSR_PRIM_UPSTREAM                   ((CsrPrim) (0x8000))
 
 /************************************************************************************
  * Primitive definitions for Synergy framework
  ************************************************************************************/
-#define CSR_SYNERGY_EVENT_CLASS_BASE        ((CsrUint16) (0x0600))
+#define CSR_SYNERGY_EVENT_CLASS_BASE        ((u16) (0x0600))
 
-#define CSR_HCI_PRIM                        ((CsrUint16) (0x0000 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_BCCMD_PRIM                      ((CsrUint16) (0x0001 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_HQ_PRIM                         ((CsrUint16) (0x0002 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_VM_PRIM                         ((CsrUint16) (0x0003 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_TM_BLUECORE_PRIM                ((CsrUint16) (0x0004 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_FP_PRIM                         ((CsrUint16) (0x0005 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_IP_SOCKET_PRIM                  ((CsrUint16) (0x0006 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_IP_ETHER_PRIM                   ((CsrUint16) (0x0007 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_IP_IFCONFIG_PRIM                ((CsrUint16) (0x0008 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_IP_INTERNAL_PRIM                ((CsrUint16) (0x0009 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_FSAL_PRIM                       ((CsrUint16) (0x000A | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_DATA_STORE_PRIM                 ((CsrUint16) (0x000B | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_AM_PRIM                         ((CsrUint16) (0x000C | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_TLS_PRIM                        ((CsrUint16) (0x000D | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_DHCP_SERVER_PRIM                ((CsrUint16) (0x000E | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_TFTP_PRIM                       ((CsrUint16) (0x000F | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_DSPM_PRIM                       ((CsrUint16) (0x0010 | CSR_SYNERGY_EVENT_CLASS_BASE))
-#define CSR_TLS_INTERNAL_PRIM               ((CsrUint16) (0x0011 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_HCI_PRIM                        ((u16) (0x0000 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_BCCMD_PRIM                      ((u16) (0x0001 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_HQ_PRIM                         ((u16) (0x0002 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_VM_PRIM                         ((u16) (0x0003 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TM_BLUECORE_PRIM                ((u16) (0x0004 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_FP_PRIM                         ((u16) (0x0005 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_SOCKET_PRIM                  ((u16) (0x0006 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_ETHER_PRIM                   ((u16) (0x0007 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_IFCONFIG_PRIM                ((u16) (0x0008 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_INTERNAL_PRIM                ((u16) (0x0009 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_FSAL_PRIM                       ((u16) (0x000A | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_DATA_STORE_PRIM                 ((u16) (0x000B | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_AM_PRIM                         ((u16) (0x000C | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TLS_PRIM                        ((u16) (0x000D | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_DHCP_SERVER_PRIM                ((u16) (0x000E | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TFTP_PRIM                       ((u16) (0x000F | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_DSPM_PRIM                       ((u16) (0x0010 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TLS_INTERNAL_PRIM               ((u16) (0x0011 | CSR_SYNERGY_EVENT_CLASS_BASE))
 
 #define NUMBER_OF_CSR_FW_EVENTS             (CSR_DSPM_PRIM - CSR_SYNERGY_EVENT_CLASS_BASE + 1)
 
-#define CSR_SYNERGY_EVENT_CLASS_MISC_BASE   ((CsrUint16) (0x06A0))
+#define CSR_SYNERGY_EVENT_CLASS_MISC_BASE   ((u16) (0x06A0))
 
-#define CSR_UI_PRIM                         ((CsrUint16) (0x0000 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
-#define CSR_APP_PRIM                        ((CsrUint16) (0x0001 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
-#define CSR_SDIO_PROBE_PRIM                 ((CsrUint16) (0x0002 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+#define CSR_UI_PRIM                         ((u16) (0x0000 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+#define CSR_APP_PRIM                        ((u16) (0x0001 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+#define CSR_SDIO_PROBE_PRIM                 ((u16) (0x0002 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
 
 #define NUMBER_OF_CSR_FW_MISC_EVENTS        (CSR_SDIO_PROBE_PRIM - CSR_SYNERGY_EVENT_CLASS_MISC_BASE + 1)
 
-#define CSR_ENV_PRIM                        ((CsrUint16) (0x00FF | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+#define CSR_ENV_PRIM                        ((u16) (0x00FF | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_result.h b/drivers/staging/csr/csr_result.h
index 249b4990c47..68fb7599bb8 100644
--- a/drivers/staging/csr/csr_result.h
+++ b/drivers/staging/csr/csr_result.h
@@ -16,7 +16,7 @@
 extern "C" {
 #endif
 
-typedef CsrUint16 CsrResult;
+typedef u16 CsrResult;
 #define CSR_RESULT_SUCCESS  ((CsrResult) 0x0000)
 #define CSR_RESULT_FAILURE  ((CsrResult) 0xFFFF)
 
diff --git a/drivers/staging/csr/csr_sched.h b/drivers/staging/csr/csr_sched.h
index 2f982bbfb72..944b7c13a05 100644
--- a/drivers/staging/csr/csr_sched.h
+++ b/drivers/staging/csr/csr_sched.h
@@ -20,10 +20,10 @@ extern "C" {
 typedef CsrUint32 CsrSchedIdentifier;
 
 /* A task identifier */
-typedef CsrUint16 CsrSchedTaskId;
+typedef u16 CsrSchedTaskId;
 
 /* A queue identifier */
-typedef CsrUint16 CsrSchedQid;
+typedef u16 CsrSchedQid;
 #define CSR_SCHED_QID_INVALID     ((CsrSchedQid) 0xFFFF)
 
 /* A message identifier */
@@ -50,7 +50,7 @@ typedef void (*schedEntryFunction_t)(void **inst);
 /*
  * Background interrupt definitions
  */
-typedef CsrUint16 CsrSchedBgint;
+typedef u16 CsrSchedBgint;
 #define CSR_SCHED_BGINT_INVALID ((CsrSchedBgint) 0xFFFF)
 
 typedef void (*CsrSchedBgintHandler)(void *);
@@ -133,14 +133,14 @@ void CsrSchedBgintSet(CsrSchedBgint bgint);
  *----------------------------------------------------------------------------*/
 #if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
 void CsrSchedMessagePutStringLog(CsrSchedQid q,
-    CsrUint16 mi,
+    u16 mi,
     void *mv,
     CsrUint32 line,
     const CsrCharString *file);
 #define CsrSchedMessagePut(q, mi, mv) CsrSchedMessagePutStringLog((q), (mi), (mv), __LINE__, __FILE__)
 #else
 void CsrSchedMessagePut(CsrSchedQid q,
-    CsrUint16 mi,
+    u16 mi,
     void *mv);
 #endif
 
@@ -164,14 +164,14 @@ void CsrSchedMessagePut(CsrSchedQid q,
  *
  *----------------------------------------------------------------------------*/
 #if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
-void CsrSchedMessageBroadcastStringLog(CsrUint16 mi,
+void CsrSchedMessageBroadcastStringLog(u16 mi,
     void *(*msg_build_func)(void *),
     void *msg_build_ptr,
     CsrUint32 line,
     const CsrCharString *file);
 #define CsrSchedMessageBroadcast(mi, fn, ptr) CsrSchedMessageBroadcastStringLog((mi), (fn), (ptr), __LINE__, __FILE__)
 #else
-void CsrSchedMessageBroadcast(CsrUint16 mi,
+void CsrSchedMessageBroadcast(u16 mi,
     void *(*msg_build_func)(void *),
     void *msg_build_ptr);
 #endif
@@ -182,7 +182,7 @@ void CsrSchedMessageBroadcast(CsrUint16 mi,
  *
  *  DESCRIPTION
  *      Obtains a message from the message queue belonging to the calling task.
- *      The message consists of one or both of a CsrUint16 and a void *.
+ *      The message consists of one or both of a u16 and a void *.
  *
  *  RETURNS
  *      CsrBool - TRUE if a message has been obtained from the queue, else FALSE.
@@ -193,7 +193,7 @@ void CsrSchedMessageBroadcast(CsrUint16 mi,
  *      them message is discarded.
  *
  *----------------------------------------------------------------------------*/
-CsrBool CsrSchedMessageGet(CsrUint16 *pmi, void **pmv);
+CsrBool CsrSchedMessageGet(u16 *pmi, void **pmv);
 
 /*----------------------------------------------------------------------------*
  *  NAME
@@ -219,16 +219,16 @@ CsrBool CsrSchedMessageGet(CsrUint16 *pmi, void **pmv);
  *----------------------------------------------------------------------------*/
 #if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
 CsrSchedTid CsrSchedTimerSetStringLog(CsrTime delay,
-    void (*fn)(CsrUint16 mi, void *mv),
-    CsrUint16 fniarg,
+    void (*fn)(u16 mi, void *mv),
+    u16 fniarg,
     void *fnvarg,
     CsrUint32 line,
     const CsrCharString *file);
 #define CsrSchedTimerSet(d, fn, fni, fnv) CsrSchedTimerSetStringLog((d), (fn), (fni), (fnv), __LINE__, __FILE__)
 #else
 CsrSchedTid CsrSchedTimerSet(CsrTime delay,
-    void (*fn)(CsrUint16 mi, void *mv),
-    CsrUint16 fniarg,
+    void (*fn)(u16 mi, void *mv),
+    u16 fniarg,
     void *fnvarg);
 #endif
 
@@ -246,14 +246,14 @@ CsrSchedTid CsrSchedTimerSet(CsrTime delay,
  *----------------------------------------------------------------------------*/
 #if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
 CsrBool CsrSchedTimerCancelStringLog(CsrSchedTid eventid,
-    CsrUint16 *pmi,
+    u16 *pmi,
     void **pmv,
     CsrUint32 line,
     const CsrCharString *file);
 #define CsrSchedTimerCancel(e, pmi, pmv) CsrSchedTimerCancelStringLog((e), (pmi), (pmv), __LINE__, __FILE__)
 #else
 CsrBool CsrSchedTimerCancel(CsrSchedTid eventid,
-    CsrUint16 *pmi,
+    u16 *pmi,
     void **pmv);
 #endif
 
diff --git a/drivers/staging/csr/csr_sdio.h b/drivers/staging/csr/csr_sdio.h
index 2ce4f167d1b..0b24f55aa0b 100644
--- a/drivers/staging/csr/csr_sdio.h
+++ b/drivers/staging/csr/csr_sdio.h
@@ -52,8 +52,8 @@ extern "C" {
  *----------------------------------------------------------------------------*/
 typedef struct
 {
-    CsrUint16 manfId;       /* Vendor ID to match or CSR_SDIO_ANY_MANF_ID */
-    CsrUint16 cardId;       /* Device ID to match or CSR_SDIO_ANY_CARD_ID */
+    u16 manfId;       /* Vendor ID to match or CSR_SDIO_ANY_MANF_ID */
+    u16 cardId;       /* Device ID to match or CSR_SDIO_ANY_CARD_ID */
     u8  sdioFunction; /* SDIO Function number to match or CSR_SDIO_ANY_SDIO_FUNCTION */
     u8  sdioInterface; /* SDIO Standard Interface Code to match or CSR_SDIO_ANY_SDIO_INTERFACE */
 } CsrSdioFunctionId;
@@ -84,7 +84,7 @@ typedef struct
 typedef struct
 {
     CsrSdioFunctionId sdioId;
-    CsrUint16         blockSize; /* Actual configured block size, or 0 if unconfigured */
+    u16         blockSize; /* Actual configured block size, or 0 if unconfigured */
     CsrUint32         features; /* Bit mask with any of CSR_SDIO_FEATURE_* set */
     void             *device; /* Handle of device containing the function */
     void             *driverData; /* For use by the Function Driver */
@@ -434,7 +434,7 @@ void CsrSdioResumeAcknowledge(CsrSdioFunction *function, CsrResult result);
  *            (after the second operation) is in the valid range.
  *
  *----------------------------------------------------------------------------*/
-CsrResult CsrSdioBlockSizeSet(CsrSdioFunction *function, CsrUint16 blockSize);
+CsrResult CsrSdioBlockSizeSet(CsrSdioFunction *function, u16 blockSize);
 
 /*----------------------------------------------------------------------------*
  *  NAME
@@ -563,10 +563,10 @@ void CsrSdioWrite8Async(CsrSdioFunction *function, CsrUint32 address, u8 data, C
  *            the callback function.
  *
  *----------------------------------------------------------------------------*/
-CsrResult CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data);
-CsrResult CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data);
-void CsrSdioRead16Async(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data, CsrSdioAsyncCallback callback);
-void CsrSdioWrite16Async(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data, CsrSdioAsyncCallback callback);
+CsrResult CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, u16 *data);
+CsrResult CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, u16 data);
+void CsrSdioRead16Async(CsrSdioFunction *function, CsrUint32 address, u16 *data, CsrSdioAsyncCallback callback);
+void CsrSdioWrite16Async(CsrSdioFunction *function, CsrUint32 address, u16 data, CsrSdioAsyncCallback callback);
 
 /*----------------------------------------------------------------------------*
  *  NAME
diff --git a/drivers/staging/csr/csr_serialize_primitive_types.c b/drivers/staging/csr/csr_serialize_primitive_types.c
index 41bd4bec9eb..3b20b7d6304 100644
--- a/drivers/staging/csr/csr_serialize_primitive_types.c
+++ b/drivers/staging/csr/csr_serialize_primitive_types.c
@@ -23,7 +23,7 @@ void CsrUint8Des(u8 *value, u8 *buffer, CsrSize *offset)
 }
 EXPORT_SYMBOL_GPL(CsrUint8Des);
 
-void CsrUint16Des(CsrUint16 *value, u8 *buffer, CsrSize *offset)
+void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset)
 {
     *value = (buffer[*offset + 0] << 0) |
              (buffer[*offset + 1] << 8);
@@ -95,7 +95,7 @@ void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value)
 }
 EXPORT_SYMBOL_GPL(CsrUint8Ser);
 
-void CsrUint16Ser(u8 *buffer, CsrSize *offset, CsrUint16 value)
+void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value)
 {
     buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
     buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
@@ -150,7 +150,7 @@ void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const CsrUtf16String *value)
 
         for (i = 0; i < length; i++)
         {
-            CsrUint16Ser(buffer, offset, (CsrUint16) value[i]);
+            CsrUint16Ser(buffer, offset, (u16) value[i]);
         }
     }
     else
diff --git a/drivers/staging/csr/csr_time.h b/drivers/staging/csr/csr_time.h
index 0ede47e911f..032942712b6 100644
--- a/drivers/staging/csr/csr_time.h
+++ b/drivers/staging/csr/csr_time.h
@@ -43,7 +43,7 @@ typedef CsrUint32 CsrTime;
 typedef struct
 {
     CsrUint32 sec;
-    CsrUint16 msec;
+    u16 msec;
 } CsrTimeUtc;
 
 
diff --git a/drivers/staging/csr/csr_types.h b/drivers/staging/csr/csr_types.h
index e2950602081..0e5abe54497 100644
--- a/drivers/staging/csr/csr_types.h
+++ b/drivers/staging/csr/csr_types.h
@@ -33,7 +33,6 @@ typedef uintptr_t CsrUintptr;   /* Unsigned integer large enough to hold any poi
 typedef ptrdiff_t CsrIntptr;    /* intptr_t is not defined in kernel. Use the equivalent ptrdiff_t. */
 
 /* Unsigned fixed width types */
-typedef uint16_t CsrUint16;
 typedef uint32_t CsrUint32;
 
 /* Signed fixed width types */
@@ -46,7 +45,7 @@ typedef u8 CsrBool;
 /* String types */
 typedef char CsrCharString;
 typedef u8 CsrUtf8String;
-typedef CsrUint16 CsrUtf16String;   /* 16-bit UTF16 strings */
+typedef u16 CsrUtf16String;   /* 16-bit UTF16 strings */
 typedef CsrUint32 CsrUint24;
 
 /*
diff --git a/drivers/staging/csr/csr_unicode.h b/drivers/staging/csr/csr_unicode.h
index 3d86de424b9..64519c0d311 100644
--- a/drivers/staging/csr/csr_unicode.h
+++ b/drivers/staging/csr/csr_unicode.h
@@ -28,8 +28,8 @@ CsrUtf16String *CsrUtf82Utf16String(const CsrUtf8String *utf8String);
 CsrUtf16String *CsrUtf16StrCpy(CsrUtf16String *target, const CsrUtf16String *source);
 CsrUtf16String *CsrUtf16StringDuplicate(const CsrUtf16String *source);
 
-CsrUint16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2);
-CsrUint16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count);
+u16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2);
+u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count);
 
 CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, CsrUint32 count);
 CsrUtf16String *CsrUtf16ConcatenateTexts(const CsrUtf16String *inputText1, const CsrUtf16String *inputText2,
diff --git a/drivers/staging/csr/csr_utf16.c b/drivers/staging/csr/csr_utf16.c
index 6f709da0769..7e724da7808 100644
--- a/drivers/staging/csr/csr_utf16.c
+++ b/drivers/staging/csr/csr_utf16.c
@@ -75,7 +75,7 @@ static const CsrUint32 offsetsFromUtf8[4] =
 *********************************************************************************/
 CsrUtf16String *CsrUint32ToUtf16String(CsrUint32 number)
 {
-    CsrUint16 count, noOfDigits;
+    u16 count, noOfDigits;
     CsrUtf16String *output;
     CsrUint32 tempNumber;
 
@@ -115,10 +115,10 @@ CsrUtf16String *CsrUint32ToUtf16String(CsrUint32 number)
 *********************************************************************************/
 CsrUint32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString)
 {
-    CsrUint16 numLen, count;
+    u16 numLen, count;
     CsrUint32 newNumber = 0;
 
-    numLen = (CsrUint16) CsrUtf16StrLen(unicodeString);
+    numLen = (u16) CsrUtf16StrLen(unicodeString);
 
     if ((numLen > 10) || (numLen == 0) || (unicodeString == NULL)) /*CSRMAX number is 4.294.967.295 */
     {
@@ -673,15 +673,15 @@ CsrUtf16String *CsrUtf82Utf16String(const CsrUtf8String *utf8String)
 
             ch -= offsetsFromUtf8[extraBytes2Read];
 
-            if (ch <= 0xFFFF) /* Character can be encoded in one CsrUint16 */
+            if (ch <= 0xFFFF) /* Character can be encoded in one u16 */
             {
-                *dest++ = (CsrUint16) ch;
+                *dest++ = (u16) ch;
             }
-            else /* The character needs two CsrUint16 */
+            else /* The character needs two u16 */
             {
                 ch -= UNI_HALF_BASE;
-                *dest++ = (CsrUint16) ((ch >> UNI_HALF_SHIFT) | UNI_SUR_HIGH_START);
-                *dest++ = (CsrUint16) ((ch & 0x03FF) | UNI_SUR_LOW_START);
+                *dest++ = (u16) ((ch >> UNI_HALF_SHIFT) | UNI_SUR_HIGH_START);
+                *dest++ = (u16) ((ch & 0x03FF) | UNI_SUR_LOW_START);
             }
         }
     }
@@ -753,7 +753,7 @@ CsrUtf16String *CsrUtf16StringDuplicate(const CsrUtf16String *source)
 *   Output:         0: if the strings are identical.
 *
 *********************************************************************************/
-CsrUint16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2)
+u16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2)
 {
     while (*string1 || *string2)
     {
@@ -781,7 +781,7 @@ CsrUint16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *s
 *   Output:         0: if the strings are identical.
 *
 *********************************************************************************/
-CsrUint16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count)
+u16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count)
 {
     while ((*string1 || *string2) && count--)
     {
diff --git a/drivers/staging/csr/csr_util.c b/drivers/staging/csr/csr_util.c
index 83721fe8654..32c114b9825 100644
--- a/drivers/staging/csr/csr_util.c
+++ b/drivers/staging/csr/csr_util.c
@@ -55,7 +55,7 @@ u8 CsrBitCountDense(CsrUint32 n)
 /*------------------------------------------------------------------*/
 CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue)
 {
-    CsrUint16 currentIndex = 0;
+    u16 currentIndex = 0;
     *returnValue = 0;
     if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
     {
@@ -77,9 +77,9 @@ CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue)
     return FALSE;
 }
 
-CsrBool CsrHexStrToUint16(const CsrCharString *string, CsrUint16 *returnValue)
+CsrBool CsrHexStrToUint16(const CsrCharString *string, u16 *returnValue)
 {
-    CsrUint16 currentIndex = 0;
+    u16 currentIndex = 0;
     *returnValue = 0;
     if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
     {
@@ -89,7 +89,7 @@ CsrBool CsrHexStrToUint16(const CsrCharString *string, CsrUint16 *returnValue)
     {
         while (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
         {
-            *returnValue = (CsrUint16) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
+            *returnValue = (u16) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
             currentIndex++;
             if (currentIndex >= 4)
             {
@@ -103,7 +103,7 @@ CsrBool CsrHexStrToUint16(const CsrCharString *string, CsrUint16 *returnValue)
 
 CsrBool CsrHexStrToUint32(const CsrCharString *string, CsrUint32 *returnValue)
 {
-    CsrUint16 currentIndex = 0;
+    u16 currentIndex = 0;
     *returnValue = 0;
     if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
     {
@@ -190,14 +190,14 @@ void CsrIntToBase10(CsrInt32 number, CsrCharString *str)
     CsrStrCpy(str, res);
 }
 
-void CsrUInt16ToHex(CsrUint16 number, CsrCharString *str)
+void CsrUInt16ToHex(u16 number, CsrCharString *str)
 {
-    CsrUint16 index;
-    CsrUint16 currentValue;
+    u16 index;
+    u16 currentValue;
 
     for (index = 0; index < 4; index++)
     {
-        currentValue = (CsrUint16) (number & 0x000F);
+        currentValue = (u16) (number & 0x000F);
         number >>= 4;
         str[3 - index] = (char) (currentValue > 9 ? currentValue + 55 : currentValue + '0');
     }
@@ -206,7 +206,7 @@ void CsrUInt16ToHex(CsrUint16 number, CsrCharString *str)
 
 void CsrUInt32ToHex(CsrUint32 number, CsrCharString *str)
 {
-    CsrUint16 index;
+    u16 index;
     CsrUint32 currentValue;
 
     for (index = 0; index < 8; index++)
@@ -334,7 +334,7 @@ CsrUint32 CsrStrToInt(const CsrCharString *str)
     digit = 1;
 
     /* Start from the string end */
-    for (i = (CsrUint16) (CsrStrLen(str) - 1); i >= 0; i--)
+    for (i = (u16) (CsrStrLen(str) - 1); i >= 0; i--)
     {
         /* Only convert numbers */
         if ((str[i] >= '0') && (str[i] <= '9'))
diff --git a/drivers/staging/csr/csr_util.h b/drivers/staging/csr/csr_util.h
index e48dcbb20e3..610d35e2ee5 100644
--- a/drivers/staging/csr/csr_util.h
+++ b/drivers/staging/csr/csr_util.h
@@ -27,11 +27,11 @@ u8 CsrBitCountDense(CsrUint32 n);
 /* Base conversion */
 /*------------------------------------------------------------------*/
 CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue);
-CsrBool CsrHexStrToUint16(const CsrCharString *string, CsrUint16 *returnValue);
+CsrBool CsrHexStrToUint16(const CsrCharString *string, u16 *returnValue);
 CsrBool CsrHexStrToUint32(const CsrCharString *string, CsrUint32 *returnValue);
 CsrUint32 CsrPow(CsrUint32 base, CsrUint32 exponent);
 void CsrIntToBase10(CsrInt32 number, CsrCharString *str);
-void CsrUInt16ToHex(CsrUint16 number, CsrCharString *str);
+void CsrUInt16ToHex(u16 number, CsrCharString *str);
 void CsrUInt32ToHex(CsrUint32 number, CsrCharString *str);
 
 /*------------------------------------------------------------------*/
diff --git a/drivers/staging/csr/csr_wifi_fsm.h b/drivers/staging/csr/csr_wifi_fsm.h
index cfdf082349e..2128034a256 100644
--- a/drivers/staging/csr/csr_wifi_fsm.h
+++ b/drivers/staging/csr/csr_wifi_fsm.h
@@ -66,7 +66,7 @@ typedef void (*CsrWifiFsmExternalWakupCallbackPtr)(void *context);
  * @return
  *   CsrWifiFsmContext* fsm context
  */
-extern CsrWifiFsmContext* CsrWifiFsmInit(void *applicationContext, void *externalContext, CsrUint16 maxProcesses, CsrLogTextTaskId loggingTaskId);
+extern CsrWifiFsmContext* CsrWifiFsmInit(void *applicationContext, void *externalContext, u16 maxProcesses, CsrLogTextTaskId loggingTaskId);
 
 /**
  * @brief
@@ -143,7 +143,7 @@ extern CsrUint32 CsrWifiFsmExecute(CsrWifiFsmContext *context);
  * @return
  *   void
  */
-extern void CsrWifiFsmSendEventExternal(CsrWifiFsmContext *context, CsrWifiFsmEvent *event, CsrUint16 source, CsrUint16 destination, CsrPrim primtype, CsrUint16 id);
+extern void CsrWifiFsmSendEventExternal(CsrWifiFsmContext *context, CsrWifiFsmEvent *event, u16 source, u16 destination, CsrPrim primtype, u16 id);
 
 /**
  * @brief
@@ -202,7 +202,7 @@ extern CsrUint32 CsrWifiFsmGetNextTimeout(CsrWifiFsmContext *context);
  * @return
  *   void
  */
-extern void CsrWifiFsmFastForward(CsrWifiFsmContext *context, CsrUint16 ms);
+extern void CsrWifiFsmFastForward(CsrWifiFsmContext *context, u16 ms);
 
 /**
  * @brief
diff --git a/drivers/staging/csr/csr_wifi_fsm_event.h b/drivers/staging/csr/csr_wifi_fsm_event.h
index ef07d8a5cfb..47ca24554b6 100644
--- a/drivers/staging/csr/csr_wifi_fsm_event.h
+++ b/drivers/staging/csr/csr_wifi_fsm_event.h
@@ -30,7 +30,7 @@ extern "C" {
 typedef struct CsrWifiFsmEvent
 {
     CsrPrim     type;
-    CsrUint16   primtype;
+    u16   primtype;
     CsrSchedQid destination;
     CsrSchedQid source;
 
diff --git a/drivers/staging/csr/csr_wifi_fsm_types.h b/drivers/staging/csr/csr_wifi_fsm_types.h
index 99e60e817b9..5bc69874bc7 100644
--- a/drivers/staging/csr/csr_wifi_fsm_types.h
+++ b/drivers/staging/csr/csr_wifi_fsm_types.h
@@ -54,9 +54,9 @@ typedef struct CsrWifiFsmEventList
 typedef struct CsrWifiFsmTimerId
 {
     CsrPrim     type;
-    CsrUint16   primtype;
+    u16   primtype;
     CsrSchedQid destination;
-    CsrUint16   uniqueid;
+    u16   uniqueid;
 } CsrWifiFsmTimerId;
 
 /**
@@ -71,7 +71,7 @@ typedef struct CsrWifiFsmTimerId
 typedef struct CsrWifiFsmTimer
 {
     CsrPrim     type;
-    CsrUint16   primtype;
+    u16   primtype;
     CsrSchedQid destination;
     CsrSchedQid source;
 
@@ -109,7 +109,7 @@ typedef struct CsrWifiFsmTimerList
 {
     CsrWifiFsmTimer *first;
     CsrWifiFsmTimer *last;
-    CsrUint16        nexttimerid;
+    u16        nexttimerid;
 } CsrWifiFsmTimerList;
 
 /**
@@ -171,9 +171,9 @@ typedef void (*CsrWifiFsmProcResetFnPtr)(CsrWifiFsmContext *context);
  * @param[in]    context : External context
  *
  * @return
- *   CsrUint16 a valid destination OR CSR_WIFI_FSM_ENV
+ *   u16 a valid destination OR CSR_WIFI_FSM_ENV
  */
-typedef CsrUint16 (*CsrWifiFsmDestLookupCallbackPtr)(void *context, const CsrWifiFsmEvent *event);
+typedef u16 (*CsrWifiFsmDestLookupCallbackPtr)(void *context, const CsrWifiFsmEvent *event);
 
 
 #ifdef CSR_WIFI_FSM_DUMP_ENABLE
@@ -223,7 +223,7 @@ typedef struct
     const CsrBool               saveAll;
     const CsrWifiFsmEventEntry *eventEntryArray; /* array of transition function pointers for state */
 #ifdef CSR_LOG_ENABLE
-    CsrUint16            stateNumber;
+    u16            stateNumber;
     const CsrCharString *stateName;
 #endif
 } CsrWifiFsmTableEntry;
@@ -237,7 +237,7 @@ typedef struct
  */
 typedef struct
 {
-    CsrUint16                   numStates;         /* number of states    */
+    u16                   numStates;         /* number of states    */
     const CsrWifiFsmTableEntry *aStateEventMatrix; /* state event matrix  */
 } CsrWifiFsmTransitionFunctionTable;
 
@@ -271,12 +271,12 @@ typedef struct
  */
 typedef struct
 {
-    CsrUint16                 transitionNumber;
+    u16                 transitionNumber;
     CsrWifiFsmEvent           event;
-    CsrUint16                 fromState;
-    CsrUint16                 toState;
+    u16                 fromState;
+    u16                 toState;
     CsrWifiFsmTransitionFnPtr transitionFn;
-    CsrUint16                 transitionCount; /* number consecutive of times this transition was seen */
+    u16                 transitionCount; /* number consecutive of times this transition was seen */
 #ifdef CSR_LOG_ENABLE
     const CsrCharString *transitionName;
 #endif
@@ -288,7 +288,7 @@ typedef struct
  */
 typedef struct
 {
-    CsrUint16                  numTransitions;
+    u16                  numTransitions;
     CsrWifiFsmTransitionRecord records[CSR_WIFI_FSM_MAX_TRANSITION_HISTORY];
 } CsrWifiFsmTransitionRecords;
 #endif
@@ -304,8 +304,8 @@ typedef struct
 typedef struct
 {
     const CsrWifiFsmProcessStateMachine *fsmInfo;         /* state machine info that is constant regardless of context */
-    CsrUint16                            instanceId;      /* Runtime process id */
-    CsrUint16                            state;           /* Current state */
+    u16                            instanceId;      /* Runtime process id */
+    u16                            state;           /* Current state */
     void                                *params;          /* Instance user data */
     CsrWifiFsmEventList                  savedEventQueue; /* The saved event queue */
     struct CsrWifiFsmInstanceEntry      *subFsm;          /* Sub Fsm instance data */
@@ -358,7 +358,7 @@ typedef void (*CsrWifiFsmOnTransitionFnPtr)(void *extContext, const CsrWifiFsmEv
  * @return
  *   void
  */
-typedef void (*CsrWifiFsmOnStateChangeFnPtr)(void *extContext, CsrUint16 nextstate);
+typedef void (*CsrWifiFsmOnStateChangeFnPtr)(void *extContext, u16 nextstate);
 
 /**
  * @brief
@@ -394,8 +394,8 @@ struct CsrWifiFsmContext
     CsrBool                            useTempSaveList;       /* Should the temp save list be used            */
     CsrWifiFsmEventList                tempSaveList;          /* The temp save event queue                    */
     CsrWifiFsmEvent                   *eventForwardedOrSaved; /* The event that was forwarded or Saved        */
-    CsrUint16                          maxProcesses;          /* Size of instanceArray                        */
-    CsrUint16                          numProcesses;          /* Current number allocated in instanceArray    */
+    u16                          maxProcesses;          /* Size of instanceArray                        */
+    u16                          numProcesses;          /* Current number allocated in instanceArray    */
     CsrWifiFsmInstanceEntry           *instanceArray;         /* Array of processes for this component        */
     CsrWifiFsmInstanceEntry           *ownerInstance;         /* The Process that owns currentInstance (SubFsm support) */
     CsrWifiFsmInstanceEntry           *currentInstance;       /* Current Process that is executing            */
@@ -429,7 +429,7 @@ struct CsrWifiFsmContext
     CsrWifiFsmOnEventFnPtr       onInvalidCallback;    /* Invalid event Callback                       */
 #endif
 #ifdef CSR_WIFI_FSM_DUMP_ENABLE
-    CsrUint16 masterTransitionNumber;                  /* Increments on every transition              */
+    u16 masterTransitionNumber;                  /* Increments on every transition              */
 #endif
 };
 
diff --git a/drivers/staging/csr/csr_wifi_hip_card.h b/drivers/staging/csr/csr_wifi_hip_card.h
index fcaf27dd353..dfee5362e77 100644
--- a/drivers/staging/csr/csr_wifi_hip_card.h
+++ b/drivers/staging/csr/csr_wifi_hip_card.h
@@ -68,7 +68,7 @@ CsrResult CardIntEnabled(card_t *card, CsrBool *enabled);
 /*****************************************************************************
  * CardGetDataSlotSize
  */
-CsrUint16 CardGetDataSlotSize(card_t *card);
+u16 CardGetDataSlotSize(card_t *card);
 
 /*****************************************************************************
  * CardWriteBulkData -
@@ -93,9 +93,9 @@ void CardClearFromHostDataSlotWithoutFreeingBulkData(card_t *card, const CsrInt1
 /*****************************************************************************
  * CardGetFreeFromHostDataSlots -
  */
-CsrUint16 CardGetFreeFromHostDataSlots(card_t *card);
+u16 CardGetFreeFromHostDataSlots(card_t *card);
 
-CsrUint16 CardAreAllFromHostDataSlotsEmpty(card_t *card);
+u16 CardAreAllFromHostDataSlotsEmpty(card_t *card);
 
 CsrResult card_start_processor(card_t *card, enum unifi_dbg_processors_select which);
 
@@ -112,7 +112,7 @@ CsrResult ConvertCsrSdioToCsrHipResult(card_t *card, CsrResult csrResult);
 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
 void unifi_debug_log_to_buf(const CsrCharString *fmt, ...);
 void unifi_debug_string_to_buf(const CsrCharString *str);
-void unifi_debug_hex_to_buf(const CsrCharString *buff, CsrUint16 length);
+void unifi_debug_hex_to_buf(const CsrCharString *buff, u16 length);
 #endif
 
 
diff --git a/drivers/staging/csr/csr_wifi_hip_card_sdio.c b/drivers/staging/csr/csr_wifi_hip_card_sdio.c
index ef9c566b97f..7e75e607e33 100644
--- a/drivers/staging/csr/csr_wifi_hip_card_sdio.c
+++ b/drivers/staging/csr/csr_wifi_hip_card_sdio.c
@@ -599,8 +599,8 @@ static void _build_sdio_config_data(sdio_config_data_t *cfg_data,
 static CsrResult card_hw_init(card_t *card)
 {
     CsrUint32 slut_address;
-    CsrUint16 initialised;
-    CsrUint16 finger_print;
+    u16 initialised;
+    u16 finger_print;
     symbol_t slut;
     sdio_config_data_t *cfg_data;
     u8 cfg_data_buf[SDIO_CONFIG_DATA_SIZE];
@@ -691,7 +691,7 @@ static CsrResult card_hw_init(card_t *card)
          */
         while (!search_4slut_again)
         {
-            CsrUint16 s;
+            u16 s;
             CsrUint32 l;
 
             r = unifi_card_read16(card, slut_address, &s);
@@ -785,7 +785,7 @@ static CsrResult card_hw_init(card_t *card)
                             func_exit_r(CSR_WIFI_HIP_RESULT_INVALID_VALUE);
                             return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
                         }
-                        cfg_data->tohost_signal_padding = (CsrUint16) (card->sdio_io_block_size / cfg_data->sig_frag_size);
+                        cfg_data->tohost_signal_padding = (u16) (card->sdio_io_block_size / cfg_data->sig_frag_size);
                         unifi_info(card->ospriv, "SDIO block size %d requires %d padding chunks\n",
                                    card->sdio_io_block_size, cfg_data->tohost_signal_padding);
                         r = unifi_card_write16(card, slut.obj + SDIO_TO_HOST_SIG_PADDING_OFFSET, cfg_data->tohost_signal_padding);
@@ -1051,7 +1051,7 @@ static CsrResult card_wait_for_unifi_to_reset(card_t *card)
         }
         if (r == CSR_RESULT_SUCCESS)
         {
-            CsrUint16 mbox2;
+            u16 mbox2;
             CsrInt16 enabled = io_enable & (1 << card->function);
 
             if (!enabled)
@@ -1236,7 +1236,7 @@ static CsrResult card_wait_for_unifi_to_disable(card_t *card)
 CsrResult card_wait_for_firmware_to_start(card_t *card, CsrUint32 *paddr)
 {
     CsrInt32 i;
-    CsrUint16 mbox0, mbox1;
+    u16 mbox0, mbox1;
     CsrResult r;
 
     func_enter();
@@ -1402,7 +1402,7 @@ CsrResult unifi_capture_panic(card_t *card)
  */
 static CsrResult card_access_panic(card_t *card)
 {
-    CsrUint16 data_u16 = 0;
+    u16 data_u16 = 0;
     CsrInt32 i;
     CsrResult r, sr;
 
@@ -1535,7 +1535,7 @@ static CsrResult card_access_panic(card_t *card)
 void unifi_read_panic(card_t *card)
 {
     CsrResult r;
-    CsrUint16 p_code, p_arg;
+    u16 p_code, p_arg;
 
     func_enter();
 
@@ -2045,7 +2045,7 @@ static CsrResult card_init_slots(card_t *card)
 
     /* Get initial signal counts from UniFi, in case it has not been reset. */
     {
-        CsrUint16 s;
+        u16 s;
 
         /* Get the from-host-signals-written count */
         r = unifi_card_read16(card, card->sdio_ctrl_addr + 0, &s);
@@ -2219,11 +2219,11 @@ static void CardReassignDynamicReservation(card_t *card)
  */
 static void CardCheckDynamicReservation(card_t *card, unifi_TrafficQueue queue)
 {
-    CsrUint16 q_len, active_queues = 0, excess_queue_slots, div_extra_slots,
+    u16 q_len, active_queues = 0, excess_queue_slots, div_extra_slots,
               queue_fair_share, reserved_slots = 0, q, excess_need_queues = 0, unmovable_slots = 0;
     CsrInt32 i;
     q_t *sigq;
-    CsrUint16 num_data_slots = card->config_data.num_fromhost_data_slots - UNIFI_RESERVED_COMMAND_SLOTS;
+    u16 num_data_slots = card->config_data.num_fromhost_data_slots - UNIFI_RESERVED_COMMAND_SLOTS;
 
     func_enter();
 
@@ -2453,7 +2453,7 @@ void CardClearFromHostDataSlotWithoutFreeingBulkData(card_t *card, const CsrInt1
 
 #endif
 
-CsrUint16 CardGetDataSlotSize(card_t *card)
+u16 CardGetDataSlotSize(card_t *card)
 {
     return card->config_data.data_slot_size;
 } /* CardGetDataSlotSize() */
@@ -2472,9 +2472,9 @@ CsrUint16 CardGetDataSlotSize(card_t *card)
  *      Number of free from-host bulk data slots.
  * ---------------------------------------------------------------------------
  */
-CsrUint16 CardGetFreeFromHostDataSlots(card_t *card)
+u16 CardGetFreeFromHostDataSlots(card_t *card)
 {
-    CsrUint16 i, n = 0;
+    u16 i, n = 0;
 
     func_enter();
 
@@ -2507,9 +2507,9 @@ CsrUint16 CardGetFreeFromHostDataSlots(card_t *card)
  *      0       Some or all the from-host bulk data slots are in use.
  * ---------------------------------------------------------------------------
  */
-CsrUint16 CardAreAllFromHostDataSlotsEmpty(card_t *card)
+u16 CardAreAllFromHostDataSlotsEmpty(card_t *card)
 {
-    CsrUint16 i;
+    u16 i;
 
     for (i = 0; i < card->config_data.num_fromhost_data_slots; i++)
     {
@@ -2642,7 +2642,7 @@ static CsrResult unifi_read_chip_version(card_t *card)
 {
     CsrUint32 gbl_chip_version;
     CsrResult r;
-    CsrUint16 ver;
+    u16 ver;
 
     func_enter();
 
@@ -2700,7 +2700,7 @@ static CsrResult unifi_read_chip_version(card_t *card)
 static CsrResult unifi_reset_hardware(card_t *card)
 {
     CsrResult r;
-    CsrUint16 new_block_size = UNIFI_IO_BLOCK_SIZE;
+    u16 new_block_size = UNIFI_IO_BLOCK_SIZE;
     CsrResult csrResult;
 
     func_enter();
@@ -3402,7 +3402,7 @@ CsrResult CardIntEnabled(card_t *card, CsrBool *enabled)
  */
 CsrResult CardWriteBulkData(card_t *card, card_signal_t *csptr, unifi_TrafficQueue queue)
 {
-    CsrUint16 i, slots[UNIFI_MAX_DATA_REFERENCES], j = 0;
+    u16 i, slots[UNIFI_MAX_DATA_REFERENCES], j = 0;
     u8 *packed_sigptr, num_slots_required = 0;
     bulk_data_desc_t *bulkdata = csptr->bulkdata;
     CsrInt16 h, nslots;
@@ -3512,7 +3512,7 @@ CsrResult CardWriteBulkData(card_t *card, card_signal_t *csptr, unifi_TrafficQue
              * Fill in the slot number in the SIGNAL structure but
              * preserve the offset already in there
              */
-            SET_PACKED_DATAREF_SLOT(packed_sigptr, i, slots[j] | (((CsrUint16)packed_sigptr[SIZEOF_SIGNAL_HEADER + (i * SIZEOF_DATAREF) + 1]) << 8));
+            SET_PACKED_DATAREF_SLOT(packed_sigptr, i, slots[j] | (((u16)packed_sigptr[SIZEOF_SIGNAL_HEADER + (i * SIZEOF_DATAREF) + 1]) << 8));
             SET_PACKED_DATAREF_LEN(packed_sigptr, i, bulkdata[i].data_length);
 
             /* Do not copy the data, just store the information to them */
@@ -3607,7 +3607,7 @@ bulk_data_desc_t* card_find_data_slot(card_t *card, CsrInt16 slot)
 static CsrResult firmware_present_in_flash(card_t *card)
 {
     CsrResult r;
-    CsrUint16 m1, m5;
+    u16 m1, m5;
 
     if (ChipHelper_HasRom(card->helper))
     {
@@ -4107,7 +4107,7 @@ void unifi_get_hip_qos_info(card_t *card, unifi_HipQosInfo *hipqosinfo)
     CsrUint32 occupied_fh;
 
     q_t *sigq;
-    CsrUint16 nslots, i;
+    u16 nslots, i;
 
     CsrMemSet(hipqosinfo, 0, sizeof(unifi_HipQosInfo));
 
@@ -4142,7 +4142,7 @@ void unifi_get_hip_qos_info(card_t *card, unifi_HipQosInfo *hipqosinfo)
 
     occupied_fh = (card->from_host_signals_w - count_fhr) % 128;
 
-    hipqosinfo->free_fh_fw_slots = (CsrUint16)(card->config_data.num_fromhost_sig_frags - occupied_fh);
+    hipqosinfo->free_fh_fw_slots = (u16)(card->config_data.num_fromhost_sig_frags - occupied_fh);
 }
 
 
diff --git a/drivers/staging/csr/csr_wifi_hip_card_sdio.h b/drivers/staging/csr/csr_wifi_hip_card_sdio.h
index 2615169d426..8c81856e5a0 100644
--- a/drivers/staging/csr/csr_wifi_hip_card_sdio.h
+++ b/drivers/staging/csr/csr_wifi_hip_card_sdio.h
@@ -115,25 +115,25 @@ typedef struct
      * indicate incompatible changes. The LSB gives the minor revision number,
      * used to indicate changes that maintain backwards compatibility.
      */
-    CsrUint16 version;
+    u16 version;
 
     /*
      * offset from the start of the shared data memory to the SD IO
      * control structure.
      */
-    CsrUint16 sdio_ctrl_offset;
+    u16 sdio_ctrl_offset;
 
     /* Buffer handle of the from-host signal queue */
-    CsrUint16 fromhost_sigbuf_handle;
+    u16 fromhost_sigbuf_handle;
 
     /* Buffer handle of the to-host signal queue */
-    CsrUint16 tohost_sigbuf_handle;
+    u16 tohost_sigbuf_handle;
 
     /*
      * Maximum number of signal primitive or bulk data command fragments that may be
      * pending in the to-hw signal queue.
      */
-    CsrUint16 num_fromhost_sig_frags;
+    u16 num_fromhost_sig_frags;
 
     /*
      * Number of signal primitive or bulk data command fragments that must be pending
@@ -145,42 +145,42 @@ typedef struct
      * Note that the hw may place more signals in the to-host signal queue
      * than indicated by this field.
      */
-    CsrUint16 num_tohost_sig_frags;
+    u16 num_tohost_sig_frags;
 
     /*
      * Number of to-hw bulk data slots. Slots are numbered from 0 (zero) to
      * one less than the value in this field
      */
-    CsrUint16 num_fromhost_data_slots;
+    u16 num_fromhost_data_slots;
 
     /*
      * Number of frm-hw bulk data slots. Slots are numbered from 0 (zero) to
      * one less than the value in this field
      */
-    CsrUint16 num_tohost_data_slots;
+    u16 num_tohost_data_slots;
 
     /*
      * Size of the bulk data slots (2 octets)
      * The size of the bulk data slots in octets. This will usually be
      * the size of the largest MSDU. The value should always be even.
      */
-    CsrUint16 data_slot_size;
+    u16 data_slot_size;
 
     /*
      * Indicates that the host has finished the initialisation sequence.
      * Initialised to 0x0000 by the firmware, and set to 0x0001 by us.
      */
-    CsrUint16 initialised;
+    u16 initialised;
 
     /* Added by protocol version 0x0001 */
     CsrUint32 overlay_size;
 
     /* Added by protocol version 0x0300 */
-    CsrUint16 data_slot_round;
-    CsrUint16 sig_frag_size;
+    u16 data_slot_round;
+    u16 sig_frag_size;
 
     /* Added by protocol version 0x0500 */
-    CsrUint16 tohost_signal_padding;
+    u16 tohost_signal_padding;
 } sdio_config_data_t;
 
 /*
@@ -200,10 +200,10 @@ typedef struct
 /* Structure for a bulk data transfer command */
 typedef struct
 {
-    CsrUint16 cmd_and_len;   /* bits 12-15 cmd, bits 0-11 len */
-    CsrUint16 data_slot;     /* slot number, perhaps OR'd with SLOT_DIR_TO_HOST */
-    CsrUint16 offset;
-    CsrUint16 buffer_handle;
+    u16 cmd_and_len;   /* bits 12-15 cmd, bits 0-11 len */
+    u16 data_slot;     /* slot number, perhaps OR'd with SLOT_DIR_TO_HOST */
+    u16 offset;
+    u16 buffer_handle;
 } bulk_data_cmd_t;
 
 
@@ -249,7 +249,7 @@ typedef struct card_signal
     u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
 
     /* Length of the SIGNAL inside sigbuf */
-    CsrUint16 signal_length;
+    u16 signal_length;
 
     bulk_data_desc_t bulkdata[UNIFI_MAX_DATA_REFERENCES];
 } card_signal_t;
@@ -264,10 +264,10 @@ typedef struct
     card_signal_t *q_body;
 
     /* Num elements in queue (capacity is one less than this!) */
-    CsrUint16 q_length;
+    u16 q_length;
 
-    CsrUint16 q_wr_ptr;
-    CsrUint16 q_rd_ptr;
+    u16 q_wr_ptr;
+    u16 q_rd_ptr;
 
     CsrCharString name[UNIFI_QUEUE_NAME_MAX_LENGTH];
 } q_t;
@@ -283,9 +283,9 @@ typedef struct
  */
 typedef struct
 {
-    CsrUint16 from_host_used_slots[UNIFI_NO_OF_TX_QS];
-    CsrUint16 from_host_max_slots[UNIFI_NO_OF_TX_QS];
-    CsrUint16 from_host_reserved_slots[UNIFI_NO_OF_TX_QS];
+    u16 from_host_used_slots[UNIFI_NO_OF_TX_QS];
+    u16 from_host_max_slots[UNIFI_NO_OF_TX_QS];
+    u16 from_host_reserved_slots[UNIFI_NO_OF_TX_QS];
 
     /* Parameters to determine if a queue was active.
        If number of packets sent is greater than the threshold
@@ -293,11 +293,11 @@ typedef struct
        re reservation is done, it is important not to keep this
        value too low */
     /* Packets sent during this interval */
-    CsrUint16 packets_txed[UNIFI_NO_OF_TX_QS];
-    CsrUint16 total_packets_txed;
+    u16 packets_txed[UNIFI_NO_OF_TX_QS];
+    u16 total_packets_txed;
 
     /* Number of packets to see if slots need to be reassigned */
-    CsrUint16 packets_interval;
+    u16 packets_interval;
 
     /* Once a queue reaches a stable state, avoid processing */
     CsrBool queue_stable[UNIFI_NO_OF_TX_QS];
@@ -311,7 +311,7 @@ typedef struct
  *  params:
  *      const q_t *q
  *  returns:
- *      CsrUint16
+ *      u16
  */
 #define CSR_WIFI_HIP_Q_SLOTS_USED(q)     \
     (((q)->q_wr_ptr - (q)->q_rd_ptr < 0)? \
@@ -321,7 +321,7 @@ typedef struct
  *  params:
  *      const q_t *q
  *  returns:
- *      CsrUint16
+ *      u16
  */
 #define CSR_WIFI_HIP_Q_SLOTS_FREE(q)     \
     ((q)->q_length - CSR_WIFI_HIP_Q_SLOTS_USED((q)) - 1)
@@ -329,7 +329,7 @@ typedef struct
 /* Return slot signal data pointer
  *  params:
  *      const q_t *q
- *      CsrUint16 slot
+ *      u16 slot
  *  returns:
  *      card_signal_t *
  */
@@ -340,7 +340,7 @@ typedef struct
  *  params:
  *      const q_t *q
  *  returns:
- *      CsrUint16 slot offset
+ *      u16 slot offset
  */
 #define CSR_WIFI_HIP_Q_NEXT_R_SLOT(q)    \
     ((q)->q_rd_ptr)
@@ -349,7 +349,7 @@ typedef struct
  *  params:
  *      const q_t *q
  *  returns:
- *      CsrUint16 slot offset
+ *      u16 slot offset
  */
 #define CSR_WIFI_HIP_Q_NEXT_W_SLOT(q)    \
     ((q)->q_wr_ptr)
@@ -357,9 +357,9 @@ typedef struct
 /* Return updated queue pointer wrapped around its length
  *  params:
  *      const q_t *q
- *      CsrUint16 x     amount to add to queue pointer
+ *      u16 x     amount to add to queue pointer
  *  returns:
- *      CsrUint16 wrapped queue pointer
+ *      u16 wrapped queue pointer
  */
 #define CSR_WIFI_HIP_Q_WRAP(q, x)    \
     ((((x) >= (q)->q_length)?((x) % (q)->q_length) : (x)))
@@ -415,10 +415,10 @@ struct card
     CsrCharString build_id_string[128];
 
     /* Retrieve from SDIO driver. */
-    CsrUint16 chip_id;
+    u16 chip_id;
 
     /* Read from GBL_CHIP_VERSION. */
-    CsrUint16 chip_version;
+    u16 chip_version;
 
     /* From the SDIO driver (probably 1) */
     u8 function;
@@ -443,7 +443,7 @@ struct card
 #define card_tx_q_unpause(card, q)   (card->tx_q_paused_flag[q] = 0)
 #define card_tx_q_pause(card, q)   (card->tx_q_paused_flag[q] = 1)
 
-    CsrUint16 tx_q_paused_flag[UNIFI_TRAFFIC_Q_MAX + 1 + UNIFI_NO_OF_TX_QS]; /* defensive more than big enough */
+    u16 tx_q_paused_flag[UNIFI_TRAFFIC_Q_MAX + 1 + UNIFI_NO_OF_TX_QS]; /* defensive more than big enough */
 
     /* UDI callback for logging UniFi interactions */
     udi_func_t udi_hook;
@@ -507,8 +507,8 @@ struct card
     {
         u8 *buf;     /* buffer area */
         u8 *ptr;     /* current pos */
-        CsrUint16 count;   /* signal count */
-        CsrUint16 bufsize;
+        u16 count;   /* signal count */
+        u16 bufsize;
     } fh_buffer;
     struct sigbuf th_buffer;
 
@@ -563,7 +563,7 @@ struct card
     u8 memory_resources_allocated;
 
     /* UniFi SDIO I/O Block size. */
-    CsrUint16 sdio_io_block_size;
+    u16 sdio_io_block_size;
 
     /* Pad transfer sizes to SDIO block boundaries */
     CsrBool sdio_io_block_pad;
@@ -621,14 +621,14 @@ struct card
     /* Historic firmware panic codes */
     CsrUint32 panic_data_phy_addr;
     CsrUint32 panic_data_mac_addr;
-    CsrUint16 last_phy_panic_code;
-    CsrUint16 last_phy_panic_arg;
-    CsrUint16 last_mac_panic_code;
-    CsrUint16 last_mac_panic_arg;
+    u16 last_phy_panic_code;
+    u16 last_phy_panic_arg;
+    u16 last_mac_panic_code;
+    u16 last_mac_panic_arg;
 #ifdef CSR_PRE_ALLOC_NET_DATA
     bulk_data_desc_t bulk_data_desc_list[BULK_DATA_PRE_ALLOC_NUM];
-    CsrUint16        prealloc_netdata_r;
-    CsrUint16        prealloc_netdata_w;
+    u16        prealloc_netdata_r;
+    u16        prealloc_netdata_w;
 #endif
 }; /* struct card */
 
@@ -659,10 +659,10 @@ bulk_data_desc_t* card_find_data_slot(card_t *card, CsrInt16 slot);
 
 CsrResult unifi_read32(card_t *card, CsrUint32 unifi_addr, CsrUint32 *pdata);
 CsrResult unifi_readnz(card_t *card, CsrUint32 unifi_addr,
-                       void *pdata, CsrUint16 len);
+                       void *pdata, u16 len);
 CsrInt32 unifi_read_shared_count(card_t *card, CsrUint32 addr);
 
-CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len);
+CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len);
 
 CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle,
                         void *pdata, CsrUint32 len, CsrInt16 direction);
@@ -676,12 +676,12 @@ CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 data);
 CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, u8 *pdata);
 CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, u8 data);
 
-CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, CsrUint16 *pdata);
+CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, u16 *pdata);
 CsrResult unifi_read_direct32(card_t *card, CsrUint32 addr, CsrUint32 *pdata);
-CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len);
+CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len);
 
-CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, CsrUint16 data);
-CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len);
+CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, u16 data);
+CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len);
 
 CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, u8 *pdata);
 CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, u8 data);
@@ -692,8 +692,8 @@ void prealloc_netdata_free(card_t *card);
 CsrResult prealloc_netdata_alloc(card_t *card);
 #endif
 /* For diagnostic use */
-void dump(void *mem, CsrUint16 len);
-void dump16(void *mem, CsrUint16 len);
+void dump(void *mem, u16 len);
+void dump16(void *mem, u16 len);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_wifi_hip_card_sdio_intr.c b/drivers/staging/csr/csr_wifi_hip_card_sdio_intr.c
index 52a6ed3ad7e..2d3b3eadadc 100644
--- a/drivers/staging/csr/csr_wifi_hip_card_sdio_intr.c
+++ b/drivers/staging/csr/csr_wifi_hip_card_sdio_intr.c
@@ -47,14 +47,14 @@ static CsrResult handle_host_protocol(card_t *card, CsrBool *processed_something
 
 static CsrResult flush_fh_buffer(card_t *card);
 
-static CsrResult check_fh_sig_slots(card_t *card, CsrUint16 needed, CsrInt32 *space);
+static CsrResult check_fh_sig_slots(card_t *card, u16 needed, CsrInt32 *space);
 
 static CsrResult read_to_host_signals(card_t *card, CsrInt32 *processed);
 static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed);
 
 static CsrResult process_bulk_data_command(card_t *card,
                                            const u8 *cmdptr,
-                                           CsrInt16 cmd, CsrUint16 len);
+                                           CsrInt16 cmd, u16 len);
 static CsrResult process_clear_slot_command(card_t         *card,
                                             const u8 *cmdptr);
 static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed);
@@ -143,14 +143,14 @@ void unifi_debug_log_to_buf(const CsrCharString *fmt, ...)
  *
  * ---------------------------------------------------------------------------
  */
-void unifi_debug_hex_to_buf(const CsrCharString *buff, CsrUint16 length)
+void unifi_debug_hex_to_buf(const CsrCharString *buff, u16 length)
 {
     CsrCharString s[5];
-    CsrUint16 i;
+    u16 i;
 
     for (i = 0; i < length; i = i + 2)
     {
-        CsrUInt16ToHex(*((CsrUint16 *)(buff + i)), s);
+        CsrUInt16ToHex(*((u16 *)(buff + i)), s);
         unifi_debug_string_to_buf(s);
     }
 }
@@ -361,7 +361,7 @@ CsrResult unifi_bh(card_t *card, CsrUint32 *remaining)
     CsrBool pending;
     CsrInt32 iostate, j;
     const enum unifi_low_power_mode low_power_mode = card->low_power_mode;
-    CsrUint16 data_slots_used = 0;
+    u16 data_slots_used = 0;
 
 
     /* Process request to raise the maximum SDIO clock */
@@ -1029,7 +1029,7 @@ static CsrResult read_to_host_signals(card_t *card, CsrInt32 *processed)
     }
 
     card->th_buffer.ptr += unread_bytes;
-    card->th_buffer.count += (CsrUint16)unread_chunks;
+    card->th_buffer.count += (u16)unread_chunks;
 
     *processed = 1;
 
@@ -1150,10 +1150,10 @@ static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed)
     u8 *bufptr;
     bulk_data_param_t data_ptrs;
     CsrInt16 cmd;
-    CsrUint16 sig_len;
+    u16 sig_len;
     CsrInt16 i;
-    CsrUint16 chunks_in_buf;
-    CsrUint16 bytes_transferred = 0;
+    u16 chunks_in_buf;
+    u16 bytes_transferred = 0;
     CsrResult r = CSR_RESULT_SUCCESS;
 
     *processed = 0;
@@ -1205,14 +1205,14 @@ static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed)
          */
         if (cmd == SDIO_CMD_SIGNAL)
         {
-            chunks_in_buf = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(sig_len + 2));
+            chunks_in_buf = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(sig_len + 2));
         }
         else
         {
             chunks_in_buf = 1;
         }
 
-        if (chunks_in_buf > (CsrUint16)pending)
+        if (chunks_in_buf > (u16)pending)
         {
             unifi_error(card->ospriv, "incomplete signal (0x%x?): need %d chunks, got %d\n",
                         GET_SIGNAL_ID(bufptr + 2),
@@ -1235,7 +1235,7 @@ static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed)
                 for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
                 {
                     /* Retrieve dataRefs[i].DataLength */
-                    CsrUint16 data_len = GET_PACKED_DATAREF_LEN(bufptr + 2, i);
+                    u16 data_len = GET_PACKED_DATAREF_LEN(bufptr + 2, i);
 
                     /*
                      * The bulk data length in the signal can not be greater than
@@ -1316,7 +1316,7 @@ static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed)
                 {
                     /* Get host tag and transmission status */
                     CsrUint32 host_tag = GET_PACKED_MA_PACKET_CONFIRM_HOST_TAG(bufptr + 2);
-                    CsrUint16 status = GET_PACKED_MA_PACKET_CONFIRM_TRANSMISSION_STATUS(bufptr + 2);
+                    u16 status = GET_PACKED_MA_PACKET_CONFIRM_TRANSMISSION_STATUS(bufptr + 2);
 
                     unifi_trace(card->ospriv, UDBG4, "process_to_host_signals signal ID=%x host Tag=%x status=%x\n",
                                 GET_SIGNAL_ID(bufptr + 2), host_tag, status);
@@ -1327,7 +1327,7 @@ static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed)
 
                     if (status && (card->fh_slot_host_tag_record))
                     {
-                        CsrUint16 num_fh_slots = card->config_data.num_fromhost_data_slots;
+                        u16 num_fh_slots = card->config_data.num_fromhost_data_slots;
 
                         /* search through the list of slot records and match with host tag
                          * If a slot is not yet cleared then clear the slot from here
@@ -1545,7 +1545,7 @@ static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed)
  */
 static CsrResult process_clear_slot_command(card_t *card, const u8 *cmdptr)
 {
-    CsrUint16 data_slot;
+    u16 data_slot;
     CsrInt16 slot;
 
     data_slot = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cmdptr + SIZEOF_UINT16);
@@ -1619,7 +1619,7 @@ static CsrResult process_clear_slot_command(card_t *card, const u8 *cmdptr)
  * ---------------------------------------------------------------------------
  */
 static CsrResult process_bulk_data_command(card_t *card, const u8 *cmdptr,
-                                           CsrInt16 cmd, CsrUint16 len)
+                                           CsrInt16 cmd, u16 len)
 {
     bulk_data_desc_t *bdslot;
 #ifdef CSR_WIFI_ALIGNMENT_WORKAROUND
@@ -1839,7 +1839,7 @@ static CsrResult process_bulk_data_command(card_t *card, const u8 *cmdptr,
  *      CSR_RESULT_SUCCESS, otherwise CSR error code on error.
  * ---------------------------------------------------------------------------
  */
-static CsrResult check_fh_sig_slots(card_t *card, CsrUint16 needed, CsrInt32 *space_fh)
+static CsrResult check_fh_sig_slots(card_t *card, u16 needed, CsrInt32 *space_fh)
 {
     CsrUint32 count_fhw;
     CsrUint32 occupied_fh, slots_fh;
@@ -1885,8 +1885,8 @@ static CsrResult check_fh_sig_slots(card_t *card, CsrUint16 needed, CsrInt32 *sp
 */
 #define ROUND_UP_NEEDED_CHUNKS(_card, _needed_chunks) \
     { \
-        CsrUint16 _chunks_per_block; \
-        CsrUint16 _chunks_in_last_block; \
+        u16 _chunks_per_block; \
+        u16 _chunks_in_last_block; \
  \
         if (_card->sdio_io_block_pad) \
         { \
@@ -1902,7 +1902,7 @@ static CsrResult check_fh_sig_slots(card_t *card, CsrUint16 needed, CsrInt32 *sp
 
 #define ROUND_UP_SPACE_CHUNKS(_card, _space_chunks) \
     { \
-        CsrUint16 _chunks_per_block; \
+        u16 _chunks_per_block; \
  \
         if (_card->sdio_io_block_pad) \
         { \
@@ -1945,11 +1945,11 @@ static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed)
     q_t *sigq = &card->fh_command_queue;
 
     CsrResult r;
-    CsrUint16 pending_sigs;
-    CsrUint16 pending_chunks;
-    CsrUint16 needed_chunks;
+    u16 pending_sigs;
+    u16 pending_chunks;
+    u16 needed_chunks;
     CsrInt32 space_chunks;
-    CsrUint16 q_index;
+    u16 q_index;
 
     *processed = 0;
 
@@ -1973,7 +1973,7 @@ static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed)
          * Note that GET_CHUNKS_FOR() needs the size of the packed
          * (wire-formatted) structure
          */
-        pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(csptr->signal_length + 2));
+        pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(csptr->signal_length + 2));
     }
 
     /*
@@ -2003,7 +2003,7 @@ static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed)
      * Coalesce as many from-host signals as possible
      * into a single block and write using a single CMD53
      */
-    if (needed_chunks > (CsrUint16)space_chunks)
+    if (needed_chunks > (u16)space_chunks)
     {
         /* Round up to the block size if necessary */
         ROUND_UP_SPACE_CHUNKS(card, space_chunks);
@@ -2012,7 +2012,7 @@ static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed)
          * If the f/w has less free chunks than those already pending
          * return immediately.
          */
-        if ((CsrUint16)space_chunks <= card->fh_buffer.count)
+        if ((u16)space_chunks <= card->fh_buffer.count)
         {
             /*
              * No room in UniFi for any signals after the buffered bulk
@@ -2023,17 +2023,17 @@ static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed)
             card->generate_interrupt = 1;
             return CSR_RESULT_SUCCESS;
         }
-        pending_chunks = (CsrUint16)(space_chunks - card->fh_buffer.count);
+        pending_chunks = (u16)(space_chunks - card->fh_buffer.count);
     }
 
     while (pending_sigs-- && pending_chunks > 0)
     {
         card_signal_t *csptr;
         CsrInt16 i;
-        CsrUint16 sig_chunks, total_length, free_chunks_in_fh_buffer;
+        u16 sig_chunks, total_length, free_chunks_in_fh_buffer;
         bulk_data_param_t bulkdata;
         u8 *packed_sigptr;
-        CsrUint16 signal_length = 0;
+        u16 signal_length = 0;
 
         /* Retrieve the entry at the head of the queue */
         q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(sigq);
@@ -2051,15 +2051,15 @@ static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed)
         }
 
         /* Need space for 2-byte SDIO protocol header + signal */
-        sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(signal_length + 2));
+        sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(signal_length + 2));
 
         free_chunks_in_fh_buffer = GET_CHUNKS_FOR(card->config_data.sig_frag_size,
-                                                  (CsrUint16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
+                                                  (u16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
         if (free_chunks_in_fh_buffer < sig_chunks)
         {
             /* No more room */
             unifi_notice(card->ospriv, "proc_fh_cmd_q: no room in fh buffer for 0x%.4X, deferring\n",
-                         (CsrUint16)(GET_SIGNAL_ID(csptr->sigbuf)));
+                         (u16)(GET_SIGNAL_ID(csptr->sigbuf)));
             break;
         }
 
@@ -2069,7 +2069,7 @@ static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed)
         if (CSR_RESULT_FAILURE == CardWriteBulkData(card, csptr, UNIFI_TRAFFIC_Q_MLME))
         {
             unifi_notice(card->ospriv, "proc_fh_cmd_q: no fh data slots for 0x%.4X, deferring\n",
-                         (CsrUint16)(GET_SIGNAL_ID(csptr->sigbuf)));
+                         (u16)(GET_SIGNAL_ID(csptr->sigbuf)));
             break;
         }
 
@@ -2175,13 +2175,13 @@ static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed)
     CsrResult r;
     CsrInt16 n = 0;
     CsrInt32 q_no;
-    CsrUint16 pending_sigs = 0;
-    CsrUint16 pending_chunks = 0;
-    CsrUint16 needed_chunks;
+    u16 pending_sigs = 0;
+    u16 pending_chunks = 0;
+    u16 needed_chunks;
     CsrInt32 space_chunks;
-    CsrUint16 q_index;
+    u16 q_index;
     CsrUint32 host_tag = 0;
-    CsrUint16 slot_num = 0;
+    u16 slot_num = 0;
 
     *processed = 0;
 
@@ -2203,7 +2203,7 @@ static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed)
              * Note that GET_CHUNKS_FOR() needs the size of the packed
              * (wire-formatted) structure
              */
-            pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(csptr->signal_length + 2));
+            pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(csptr->signal_length + 2));
         }
     }
 
@@ -2240,12 +2240,12 @@ static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed)
 
     /* Coalesce as many from-host signals as possible
        into a single block and write using a single CMD53 */
-    if (needed_chunks > (CsrUint16)space_chunks)
+    if (needed_chunks > (u16)space_chunks)
     {
         /* Round up to the block size if necessary */
         ROUND_UP_SPACE_CHUNKS(card, space_chunks);
 
-        if ((CsrUint16)space_chunks <= card->fh_buffer.count)
+        if ((u16)space_chunks <= card->fh_buffer.count)
         {
             /*
              * No room in UniFi for any signals after the buffered bulk
@@ -2257,7 +2257,7 @@ static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed)
             return 0;
         }
 
-        pending_chunks = (CsrUint16)space_chunks - card->fh_buffer.count;
+        pending_chunks = (u16)space_chunks - card->fh_buffer.count;
     }
 
     q_no = UNIFI_NO_OF_TX_QS - 1;
@@ -2271,10 +2271,10 @@ static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed)
     do
     {
         card_signal_t *csptr;
-        CsrUint16 sig_chunks, total_length, free_chunks_in_fh_buffer;
+        u16 sig_chunks, total_length, free_chunks_in_fh_buffer;
         bulk_data_param_t bulkdata;
         u8 *packed_sigptr;
-        CsrUint16 signal_length = 0;
+        u16 signal_length = 0;
 
         /* if this queue is empty go to next one. */
         if (CSR_WIFI_HIP_Q_SLOTS_USED(&sigq[q_no]) == 0)
@@ -2299,9 +2299,9 @@ static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed)
         }
 
         /* Need space for 2-byte SDIO protocol header + signal */
-        sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(signal_length + 2));
+        sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(signal_length + 2));
         free_chunks_in_fh_buffer = GET_CHUNKS_FOR(card->config_data.sig_frag_size,
-                                                  (CsrUint16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
+                                                  (u16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
         if (free_chunks_in_fh_buffer < sig_chunks)
         {
             /* No more room */
@@ -2444,12 +2444,12 @@ static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed)
 static CsrResult flush_fh_buffer(card_t *card)
 {
     CsrResult r;
-    CsrUint16 len;
-    CsrUint16 sig_units;
-    CsrUint16 data_round;
-    CsrUint16 chunks_in_last_block;
-    CsrUint16 padding_chunks;
-    CsrUint16 i;
+    u16 len;
+    u16 sig_units;
+    u16 data_round;
+    u16 chunks_in_last_block;
+    u16 padding_chunks;
+    u16 i;
 
     len = card->fh_buffer.ptr - card->fh_buffer.buf;
 
diff --git a/drivers/staging/csr/csr_wifi_hip_card_sdio_mem.c b/drivers/staging/csr/csr_wifi_hip_card_sdio_mem.c
index d98610f3389..9953ebfd6cf 100644
--- a/drivers/staging/csr/csr_wifi_hip_card_sdio_mem.c
+++ b/drivers/staging/csr/csr_wifi_hip_card_sdio_mem.c
@@ -202,7 +202,7 @@ static CsrResult retrying_write8(card_t *card, CsrInt16 funcnum, CsrUint32 addr,
 
 
 static CsrResult retrying_read16(card_t *card, CsrInt16 funcnum,
-                                 CsrUint32 addr, CsrUint16 *pdata)
+                                 CsrUint32 addr, u16 *pdata)
 {
     CsrSdioFunction *sdio = card->sdio_if;
     CsrResult r = CSR_RESULT_SUCCESS;
@@ -263,7 +263,7 @@ static CsrResult retrying_read16(card_t *card, CsrInt16 funcnum,
 
 
 static CsrResult retrying_write16(card_t *card, CsrInt16 funcnum,
-                                  CsrUint32 addr, CsrUint16 data)
+                                  CsrUint32 addr, u16 data)
 {
     CsrSdioFunction *sdio = card->sdio_if;
     CsrResult r = CSR_RESULT_SUCCESS;
@@ -391,7 +391,7 @@ CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, u8 data)
 CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, u8 *pdata)
 {
 #ifdef CSR_WIFI_TRANSPORT_CSPI
-    CsrUint16 w;
+    u16 w;
     CsrResult r;
 
     r = retrying_read16(card, card->function, addr, &w);
@@ -433,7 +433,7 @@ CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, u8 data)
     }
 
 #ifdef CSR_WIFI_TRANSPORT_CSPI
-    return retrying_write16(card, card->function, addr, (CsrUint16)data);
+    return retrying_write16(card, card->function, addr, (u16)data);
 #else
     return retrying_write8(card, card->function, addr, data);
 #endif
@@ -462,7 +462,7 @@ CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, u8 data)
  *      even address is read.
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, CsrUint16 *pdata)
+CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, u16 *pdata)
 {
     return retrying_read16(card, card->function, addr, pdata);
 } /* unifi_read_direct16() */
@@ -490,7 +490,7 @@ CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, CsrUint16 *pdata)
  *      even address is written.
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, CsrUint16 data)
+CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, u16 data)
 {
     return retrying_write16(card, card->function, addr, data);
 } /* unifi_write_direct16() */
@@ -516,7 +516,7 @@ CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, CsrUint16 data)
 CsrResult unifi_read_direct32(card_t *card, CsrUint32 addr, CsrUint32 *pdata)
 {
     CsrResult r;
-    CsrUint16 w0, w1;
+    u16 w0, w1;
 
     r = retrying_read16(card, card->function, addr, &w0);
     if (r != CSR_RESULT_SUCCESS)
@@ -564,12 +564,12 @@ CsrResult unifi_read_direct32(card_t *card, CsrUint32 addr, CsrUint32 *pdata)
  *      even address is read.
  * ---------------------------------------------------------------------------
  */
-static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len, s8 m, CsrUint32 *num)
+static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pdata, u16 len, s8 m, CsrUint32 *num)
 {
     CsrResult r;
     CsrUint32 i;
     u8 *cptr;
-    CsrUint16 w;
+    u16 w;
 
     *num = 0;
 
@@ -631,7 +631,7 @@ static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pd
  *      even address is read.
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len)
+CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len)
 {
     CsrUint32 num;
 
@@ -664,7 +664,7 @@ CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint1
  *      This means we must write data as pairs of bytes in reverse order.
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len)
+CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, u16 len)
 {
     CsrResult r;
     u8 *cptr;
@@ -716,7 +716,7 @@ CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint
  */
 static CsrResult set_dmem_page(card_t *card, CsrUint32 dmem_addr, CsrUint32 *paddr)
 {
-    CsrUint16 page, addr;
+    u16 page, addr;
     CsrUint32 len;
     CsrResult r;
 
@@ -756,7 +756,7 @@ static CsrResult set_dmem_page(card_t *card, CsrUint32 dmem_addr, CsrUint32 *pad
 static CsrResult set_pmem_page(card_t *card, CsrUint32 pmem_addr,
                                enum chip_helper_window_type mem_type, CsrUint32 *paddr)
 {
-    CsrUint16 page, addr;
+    u16 page, addr;
     CsrUint32 len;
     CsrResult r;
 
@@ -1064,7 +1064,7 @@ CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 *pdata)
     CsrUint32 sdio_addr;
     CsrResult r;
 #ifdef CSR_WIFI_TRANSPORT_CSPI
-    CsrUint16 w;
+    u16 w;
 #endif
 
     r = set_page(card, unifi_addr, &sdio_addr);
@@ -1115,7 +1115,7 @@ CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 data)
     CsrUint32 sdio_addr;
     CsrResult r;
 #ifdef CSR_WIFI_TRANSPORT_CSPI
-    CsrUint16 w;
+    u16 w;
 #endif
 
     r = set_page(card, unifi_addr, &sdio_addr);
@@ -1162,7 +1162,7 @@ CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 data)
  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE  a bad generic pointer was specified
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, CsrUint16 *pdata)
+CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, u16 *pdata)
 {
     CsrUint32 sdio_addr;
     CsrResult r;
@@ -1199,7 +1199,7 @@ CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, CsrUint16 *pdata
  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE  a bad generic pointer was specified
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, CsrUint16 data)
+CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, u16 data)
 {
     CsrUint32 sdio_addr;
     CsrResult r;
@@ -1278,7 +1278,7 @@ CsrResult unifi_read32(card_t *card, CsrUint32 unifi_addr, CsrUint32 *pdata)
  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE  a bad generic pointer was specified
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_readn_match(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len, s8 match)
+CsrResult unifi_readn_match(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len, s8 match)
 {
     CsrUint32 sdio_addr;
     CsrResult r;
@@ -1295,13 +1295,13 @@ CsrResult unifi_readn_match(card_t *card, CsrUint32 unifi_addr, void *pdata, Csr
 } /* unifi_readn_match() */
 
 
-CsrResult unifi_card_readn(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len)
+CsrResult unifi_card_readn(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len)
 {
     return unifi_readn_match(card, unifi_addr, pdata, len, -1);
 } /* unifi_card_readn() */
 
 
-CsrResult unifi_readnz(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len)
+CsrResult unifi_readnz(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len)
 {
     return unifi_readn_match(card, unifi_addr, pdata, len, 0);
 } /* unifi_readnz() */
@@ -1384,7 +1384,7 @@ CsrInt32 unifi_read_shared_count(card_t *card, CsrUint32 addr)
  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE    an odd length or length too big.
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len)
+CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len)
 {
     CsrUint32 sdio_addr;
     CsrResult r;
@@ -1401,7 +1401,7 @@ CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint1
 
 static CsrResult csr_sdio_block_rw(card_t *card, CsrInt16 funcnum,
                                    CsrUint32 addr, u8 *pdata,
-                                   CsrUint16 count, CsrInt16 dir_is_write)
+                                   u16 count, CsrInt16 dir_is_write)
 {
     CsrResult csrResult;
 
@@ -1505,7 +1505,7 @@ CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle, void *pdata,
                      pdata, (direction == UNIFI_SDIO_READ)?"To" : "From");
         if (direction == UNIFI_SDIO_WRITE)
         {
-            dump(pdata, (CsrUint16)len);
+            dump(pdata, (u16)len);
         }
         else
         {
@@ -1529,7 +1529,7 @@ CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle, void *pdata,
     while (1)
     {
         csrResult = csr_sdio_block_rw(card, card->function, handle,
-                                      (u8 *)pdata, (CsrUint16)len,
+                                      (u8 *)pdata, (u16)len,
                                       direction);
         if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
         {
@@ -1550,7 +1550,7 @@ CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle, void *pdata,
         {
             if (dump_read)
             {
-                dump(pdata, (CsrUint16)len);
+                dump(pdata, (u16)len);
             }
             break;
         }
@@ -1699,7 +1699,7 @@ CsrResult unifi_bulk_rw_noretry(card_t *card, CsrUint32 handle, void *pdata,
     CsrResult csrResult;
 
     csrResult = csr_sdio_block_rw(card, card->function, handle,
-                                  (u8 *)pdata, (CsrUint16)len, direction);
+                                  (u8 *)pdata, (u16)len, direction);
     if (csrResult != CSR_RESULT_SUCCESS)
     {
         unifi_error(card->ospriv, "Block %s failed\n",
diff --git a/drivers/staging/csr/csr_wifi_hip_chiphelper.c b/drivers/staging/csr/csr_wifi_hip_chiphelper.c
index 729df88f2b3..efdbab010b6 100644
--- a/drivers/staging/csr/csr_wifi_hip_chiphelper.c
+++ b/drivers/staging/csr/csr_wifi_hip_chiphelper.c
@@ -58,10 +58,10 @@ static const struct chip_helper_init_values init_vals_v22_v23[] = {
       { 0x????, 0x???? }*/
 };
 
-static const CsrUint16 reset_program_a_v1_or_v2[] = {
+static const u16 reset_program_a_v1_or_v2[] = {
     0x0000
 };
-static const CsrUint16 reset_program_b_v1_or_v2[] = {
+static const u16 reset_program_b_v1_or_v2[] = {
     0x0010, 0xFE00, 0xA021, 0xFF00, 0x8111, 0x0009, 0x0CA4, 0x0114,
     0x0280, 0x04F8, 0xFE00, 0x6F25, 0x06E0, 0x0010, 0xFC00, 0x0121,
     0xFC00, 0x0225, 0xFE00, 0x7125, 0xFE00, 0x6D11, 0x03F0, 0xFE00,
@@ -591,7 +591,7 @@ ChipDescript* ChipHelper_GetVersionSdio(u8 sdio_ver)
 }
 
 
-ChipDescript* ChipHelper_GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81)
+ChipDescript* ChipHelper_GetVersionAny(u16 from_FF9A, u16 from_FE81)
 {
     CsrUint32 i;
 
@@ -624,7 +624,7 @@ ChipDescript* ChipHelper_GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81)
 }
 
 
-ChipDescript* ChipHelper_GetVersionUniFi(CsrUint16 ver)
+ChipDescript* ChipHelper_GetVersionUniFi(u16 ver)
 {
     return ChipHelper_GetVersionAny(0x0000, ver);
 }
@@ -636,7 +636,7 @@ ChipDescript *ChipHelper_Null(void)
 }
 
 
-ChipDescript* ChipHelper_GetVersionBlueCore(enum chip_helper_bluecore_age bc_age, CsrUint16 version)
+ChipDescript* ChipHelper_GetVersionBlueCore(enum chip_helper_bluecore_age bc_age, u16 version)
 {
     if (bc_age == chip_helper_bluecore_pre_bc7)
     {
@@ -664,7 +664,7 @@ CHIP_HELPER_LIST(C_DEF)
 /*
  * Map register addresses between HOST and SPI access.
  */
-CsrUint16 ChipHelper_MapAddress_SPI2HOST(ChipDescript *chip_help, CsrUint16 addr)
+u16 ChipHelper_MapAddress_SPI2HOST(ChipDescript *chip_help, u16 addr)
 {
     CsrUint32 i;
     for (i = 0; i < chip_help->map.len; i++)
@@ -678,7 +678,7 @@ CsrUint16 ChipHelper_MapAddress_SPI2HOST(ChipDescript *chip_help, CsrUint16 addr
 }
 
 
-CsrUint16 ChipHelper_MapAddress_HOST2SPI(ChipDescript *chip_help, CsrUint16 addr)
+u16 ChipHelper_MapAddress_HOST2SPI(ChipDescript *chip_help, u16 addr)
 {
     CsrUint32 i;
     for (i = 0; i < chip_help->map.len; i++)
@@ -698,7 +698,7 @@ CsrUint16 ChipHelper_MapAddress_HOST2SPI(ChipDescript *chip_help, CsrUint16 addr
    start is unusable because something else is cluttering up
    the address map then that is taken into account and this
    function returns that address justt past that. */
-CsrUint16 ChipHelper_WINDOW_ADDRESS(ChipDescript                 *chip_help,
+u16 ChipHelper_WINDOW_ADDRESS(ChipDescript                 *chip_help,
                                     enum chip_helper_window_index window)
 {
     if (window < CHIP_HELPER_WINDOW_COUNT &&
@@ -711,7 +711,7 @@ CsrUint16 ChipHelper_WINDOW_ADDRESS(ChipDescript                 *chip_help,
 
 
 /* This returns the size of the window minus any blocked section */
-CsrUint16 ChipHelper_WINDOW_SIZE(ChipDescript                 *chip_help,
+u16 ChipHelper_WINDOW_SIZE(ChipDescript                 *chip_help,
                                  enum chip_helper_window_index window)
 {
     if (window < CHIP_HELPER_WINDOW_COUNT &&
@@ -747,11 +747,11 @@ CsrInt32 ChipHelper_DecodeWindow(ChipDescript *chip_help,
                                  enum chip_helper_window_index window,
                                  enum chip_helper_window_type type,
                                  CsrUint32 offset,
-                                 CsrUint16 *page, CsrUint16 *addr, CsrUint32 *len)
+                                 u16 *page, u16 *addr, CsrUint32 *len)
 {
     const struct window_info_t *win;
     const struct window_shift_info_t *mode;
-    CsrUint16 of, pg;
+    u16 of, pg;
 
     if (window >= CHIP_HELPER_WINDOW_COUNT)
     {
@@ -774,8 +774,8 @@ CsrInt32 ChipHelper_DecodeWindow(ChipDescript *chip_help,
         return FALSE;
     }
 
-    pg = (CsrUint16)(offset >> mode->page_shift) + mode->page_offset;
-    of = (CsrUint16)(offset & ((1 << mode->page_shift) - 1));
+    pg = (u16)(offset >> mode->page_shift) + mode->page_offset;
+    of = (u16)(offset & ((1 << mode->page_shift) - 1));
     /* If 'blocked' is zero this does nothing, else decrease
        the page register and increase the offset until we aren't
        in the blocked region of the window. */
diff --git a/drivers/staging/csr/csr_wifi_hip_chiphelper.h b/drivers/staging/csr/csr_wifi_hip_chiphelper.h
index 60dff8e92e0..a539c0485d7 100644
--- a/drivers/staging/csr/csr_wifi_hip_chiphelper.h
+++ b/drivers/staging/csr/csr_wifi_hip_chiphelper.h
@@ -133,8 +133,8 @@ enum chip_helper_fixed_registers
 /* Address-value pairs for defining initialisation values */
 struct chip_helper_init_values
 {
-    CsrUint16 addr;
-    CsrUint16 value;
+    u16 addr;
+    u16 value;
 };
 
 /* A block of data that should be written to the device */
@@ -142,7 +142,7 @@ struct chip_helper_reset_values
 {
     CsrUint32        gp_address;
     CsrUint32        len;
-    const CsrUint16 *data;
+    const u16 *data;
 };
 
 /*
@@ -164,11 +164,11 @@ ChipDescript* ChipHelper_Null(void);
    FF9A is the old GBL_CHIP_VERSION register.  If the high
    eight bits are zero then the chip is a new (BC7 +) one
    and FE81 is the _new_ GBL_CHIP_VERSION register. */
-ChipDescript* ChipHelper_GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81);
+ChipDescript* ChipHelper_GetVersionAny(u16 from_FF9A, u16 from_FE81);
 
 /* The chip is a UniFi, but we don't know which type
    The parameter is the value of UNIFI_GBL_CHIP_VERSION (0xFE81) */
-ChipDescript* ChipHelper_GetVersionUniFi(CsrUint16 version);
+ChipDescript* ChipHelper_GetVersionUniFi(u16 version);
 
 /* This gets the version from the SDIO device id.  This only
    gives quite a coarse grained version, so we should update once
@@ -180,7 +180,7 @@ ChipDescript* ChipHelper_GetVersionSdio(u8 sdio_version);
    then "version" is read from FE81.  If we don't know if we're pre
    or post BC7 then we should use "GetVersionAny". */
 ChipDescript* ChipHelper_GetVersionBlueCore(enum chip_helper_bluecore_age age,
-                                            CsrUint16                     version);
+                                            u16                     version);
 
 /* The main functions of this class are built with an X macro.  This
    means we can generate the C and C++ versions from the same source
@@ -198,52 +198,52 @@ ChipDescript* ChipHelper_GetVersionBlueCore(enum chip_helper_bluecore_age age,
 #define CHIP_HELPER_LIST(m)                                             \
     CHIP_HELPER_DEF0(m, (const CsrCharString *, FriendlyName, friendly_name))     \
     CHIP_HELPER_DEF0(m, (const CsrCharString *, MarketingName, marketing_name))  \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DBG_EMU_CMD, regs->dbg_emu_cmd))       \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DBG_HOST_PROC_SELECT, regs->host.dbg_proc_select)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DBG_HOST_STOP_STATUS, regs->host.dbg_stop_status)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, HOST_WINDOW1_PAGE, regs->host.window1_page)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, HOST_WINDOW2_PAGE, regs->host.window2_page)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, HOST_WINDOW3_PAGE, regs->host.window3_page)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, HOST_IO_LOG_ADDR, regs->host.io_log_addr)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DBG_SPI_PROC_SELECT, regs->spi.dbg_proc_select)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DBG_SPI_STOP_STATUS, regs->spi.dbg_stop_status)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, SPI_WINDOW1_PAGE, regs->spi.window1_page)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, SPI_WINDOW2_PAGE, regs->spi.window2_page)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, SPI_WINDOW3_PAGE, regs->spi.window3_page)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, SPI_IO_LOG_ADDR, regs->spi.io_log_addr)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET, regs->dbg_reset))           \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_VALUE, regs->dbg_reset_value)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_WARN, regs->dbg_reset_warn)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_WARN_VALUE, regs->dbg_reset_warn_value)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_RESULT, regs->dbg_reset_result)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, WATCHDOG_DISABLE, regs->watchdog_disable)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, PROC_PC_SNOOP, regs->proc_pc_snoop))   \
-    CHIP_HELPER_DEF0(m, (CsrUint16, GBL_CHIP_VERSION, regs->gbl_chip_version)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, GBL_MISC_ENABLES, regs->gbl_misc_enables)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, XAP_PCH, regs->xap_pch))               \
-    CHIP_HELPER_DEF0(m, (CsrUint16, XAP_PCL, regs->xap_pcl))               \
-    CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX0, regs->mailbox0))             \
-    CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX1, regs->mailbox1))             \
-    CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX2, regs->mailbox2))             \
-    CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX3, regs->mailbox3))             \
-    CHIP_HELPER_DEF0(m, (CsrUint16, SDIO_HIP_HANDSHAKE, regs->sdio_hip_handshake))   \
-    CHIP_HELPER_DEF0(m, (CsrUint16, SDIO_HOST_INT, regs->sdio_host_int))   \
-    CHIP_HELPER_DEF0(m, (CsrUint16, COEX_STATUS, regs->coex_status))       \
-    CHIP_HELPER_DEF0(m, (CsrUint16, SHARED_IO_INTERRUPT, regs->shared_io_interrupt)) \
+    CHIP_HELPER_DEF0(m, (u16, DBG_EMU_CMD, regs->dbg_emu_cmd))       \
+    CHIP_HELPER_DEF0(m, (u16, DBG_HOST_PROC_SELECT, regs->host.dbg_proc_select)) \
+    CHIP_HELPER_DEF0(m, (u16, DBG_HOST_STOP_STATUS, regs->host.dbg_stop_status)) \
+    CHIP_HELPER_DEF0(m, (u16, HOST_WINDOW1_PAGE, regs->host.window1_page)) \
+    CHIP_HELPER_DEF0(m, (u16, HOST_WINDOW2_PAGE, regs->host.window2_page)) \
+    CHIP_HELPER_DEF0(m, (u16, HOST_WINDOW3_PAGE, regs->host.window3_page)) \
+    CHIP_HELPER_DEF0(m, (u16, HOST_IO_LOG_ADDR, regs->host.io_log_addr)) \
+    CHIP_HELPER_DEF0(m, (u16, DBG_SPI_PROC_SELECT, regs->spi.dbg_proc_select)) \
+    CHIP_HELPER_DEF0(m, (u16, DBG_SPI_STOP_STATUS, regs->spi.dbg_stop_status)) \
+    CHIP_HELPER_DEF0(m, (u16, SPI_WINDOW1_PAGE, regs->spi.window1_page)) \
+    CHIP_HELPER_DEF0(m, (u16, SPI_WINDOW2_PAGE, regs->spi.window2_page)) \
+    CHIP_HELPER_DEF0(m, (u16, SPI_WINDOW3_PAGE, regs->spi.window3_page)) \
+    CHIP_HELPER_DEF0(m, (u16, SPI_IO_LOG_ADDR, regs->spi.io_log_addr)) \
+    CHIP_HELPER_DEF0(m, (u16, DBG_RESET, regs->dbg_reset))           \
+    CHIP_HELPER_DEF0(m, (u16, DBG_RESET_VALUE, regs->dbg_reset_value)) \
+    CHIP_HELPER_DEF0(m, (u16, DBG_RESET_WARN, regs->dbg_reset_warn)) \
+    CHIP_HELPER_DEF0(m, (u16, DBG_RESET_WARN_VALUE, regs->dbg_reset_warn_value)) \
+    CHIP_HELPER_DEF0(m, (u16, DBG_RESET_RESULT, regs->dbg_reset_result)) \
+    CHIP_HELPER_DEF0(m, (u16, WATCHDOG_DISABLE, regs->watchdog_disable)) \
+    CHIP_HELPER_DEF0(m, (u16, PROC_PC_SNOOP, regs->proc_pc_snoop))   \
+    CHIP_HELPER_DEF0(m, (u16, GBL_CHIP_VERSION, regs->gbl_chip_version)) \
+    CHIP_HELPER_DEF0(m, (u16, GBL_MISC_ENABLES, regs->gbl_misc_enables)) \
+    CHIP_HELPER_DEF0(m, (u16, XAP_PCH, regs->xap_pch))               \
+    CHIP_HELPER_DEF0(m, (u16, XAP_PCL, regs->xap_pcl))               \
+    CHIP_HELPER_DEF0(m, (u16, MAILBOX0, regs->mailbox0))             \
+    CHIP_HELPER_DEF0(m, (u16, MAILBOX1, regs->mailbox1))             \
+    CHIP_HELPER_DEF0(m, (u16, MAILBOX2, regs->mailbox2))             \
+    CHIP_HELPER_DEF0(m, (u16, MAILBOX3, regs->mailbox3))             \
+    CHIP_HELPER_DEF0(m, (u16, SDIO_HIP_HANDSHAKE, regs->sdio_hip_handshake))   \
+    CHIP_HELPER_DEF0(m, (u16, SDIO_HOST_INT, regs->sdio_host_int))   \
+    CHIP_HELPER_DEF0(m, (u16, COEX_STATUS, regs->coex_status))       \
+    CHIP_HELPER_DEF0(m, (u16, SHARED_IO_INTERRUPT, regs->shared_io_interrupt)) \
     CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_RAM_OFFSET, prog_offset.ram)) \
     CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_ROM_OFFSET, prog_offset.rom)) \
     CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_FLASH_OFFSET, prog_offset.flash)) \
     CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_EXT_SRAM_OFFSET, prog_offset.ext_sram)) \
-    CHIP_HELPER_DEF0(m, (CsrUint16, DATA_MEMORY_RAM_OFFSET, data_offset.ram)) \
+    CHIP_HELPER_DEF0(m, (u16, DATA_MEMORY_RAM_OFFSET, data_offset.ram)) \
     CHIP_HELPER_DEF0(m, (CsrInt32, HasFlash, bools.has_flash))              \
     CHIP_HELPER_DEF0(m, (CsrInt32, HasExtSram, bools.has_ext_sram))         \
     CHIP_HELPER_DEF0(m, (CsrInt32, HasRom, bools.has_rom))                  \
     CHIP_HELPER_DEF0(m, (CsrInt32, HasBt, bools.has_bt))                    \
     CHIP_HELPER_DEF0(m, (CsrInt32, HasWLan, bools.has_wlan))                \
-    CHIP_HELPER_DEF1(m, (CsrUint16, WINDOW_ADDRESS, enum chip_helper_window_index, window)) \
-    CHIP_HELPER_DEF1(m, (CsrUint16, WINDOW_SIZE, enum chip_helper_window_index, window)) \
-    CHIP_HELPER_DEF1(m, (CsrUint16, MapAddress_SPI2HOST, CsrUint16, addr))          \
-    CHIP_HELPER_DEF1(m, (CsrUint16, MapAddress_HOST2SPI, CsrUint16, addr))          \
+    CHIP_HELPER_DEF1(m, (u16, WINDOW_ADDRESS, enum chip_helper_window_index, window)) \
+    CHIP_HELPER_DEF1(m, (u16, WINDOW_SIZE, enum chip_helper_window_index, window)) \
+    CHIP_HELPER_DEF1(m, (u16, MapAddress_SPI2HOST, u16, addr))          \
+    CHIP_HELPER_DEF1(m, (u16, MapAddress_HOST2SPI, u16, addr))          \
     CHIP_HELPER_DEF1(m, (CsrUint32, ClockStartupSequence, const struct chip_helper_init_values **, val)) \
     CHIP_HELPER_DEF1(m, (CsrUint32, HostResetSequence, const struct chip_helper_reset_values **, val))
 
@@ -406,7 +406,7 @@ CsrInt32 ChipHelper_DecodeWindow(ChipDescript *chip_help,
                                  enum chip_helper_window_index window,
                                  enum chip_helper_window_type type,
                                  CsrUint32 offset,
-                                 CsrUint16 *page, CsrUint16 *addr, CsrUint32 *len);
+                                 u16 *page, u16 *addr, CsrUint32 *len);
 
 #ifdef __cplusplus
 /* Close the extern "C" */
@@ -429,7 +429,7 @@ public:
     /* The default constructor assume a BC7 / UF105x series chip
        and that the number given is the value of UNIFI_GBL_CHIP_VERSION
        (0xFE81) */
-    ChipHelper(CsrUint16 version);
+    ChipHelper(u16 version);
 
     /* This returns the C interface magic token from a C++ instance. */
     ChipDescript* GetDescript() const
@@ -442,9 +442,9 @@ public:
     void ClearVersion();
 
     /* Load this class with data for a specific chip. */
-    void GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81);
-    void GetVersionUniFi(CsrUint16 version);
-    void GetVersionBlueCore(chip_helper_bluecore_age age, CsrUint16 version);
+    void GetVersionAny(u16 from_FF9A, u16 from_FE81);
+    void GetVersionUniFi(u16 version);
+    void GetVersionBlueCore(chip_helper_bluecore_age age, u16 version);
     void GetVersionSdio(u8 sdio_version);
 
     /* Helpers to build the definitions of the member functions. */
@@ -460,7 +460,7 @@ public:
     CsrInt32 DecodeWindow(chip_helper_window_index window,
                           chip_helper_window_type type,
                           CsrUint32 offset,
-                          CsrUint16 &page, CsrUint16 &addr, CsrUint32 &len) const;
+                          u16 &page, u16 &addr, CsrUint32 &len) const;
 
 private:
     ChipDescript *m_desc;
diff --git a/drivers/staging/csr/csr_wifi_hip_chiphelper_private.h b/drivers/staging/csr/csr_wifi_hip_chiphelper_private.h
index c0e2f2afc68..aacafe1a118 100644
--- a/drivers/staging/csr/csr_wifi_hip_chiphelper_private.h
+++ b/drivers/staging/csr/csr_wifi_hip_chiphelper_private.h
@@ -47,11 +47,11 @@ struct val_array_t
     const struct chip_helper_init_values *vals;
 };
 
-/* Just a (counted) CsrUint16 array */
+/* Just a (counted) u16 array */
 struct data_array_t
 {
     CsrUint32        len;
-    const CsrUint16 *vals;
+    const u16 *vals;
 };
 
 struct reset_prog_t
@@ -64,7 +64,7 @@ struct reset_prog_t
    different host transports. */
 struct chip_map_address_t
 {
-    CsrUint16 spi, host;
+    u16 spi, host;
 };
 
 struct map_array_t
@@ -75,38 +75,38 @@ struct map_array_t
 
 struct chip_device_regs_per_transport_t
 {
-    CsrUint16 dbg_proc_select;
-    CsrUint16 dbg_stop_status;
-    CsrUint16 window1_page;    /* PROG_PMEM1 or GW1 */
-    CsrUint16 window2_page;    /* PROG_PMEM2 or GW2 */
-    CsrUint16 window3_page;    /* SHARED or GW3 */
-    CsrUint16 io_log_addr;
+    u16 dbg_proc_select;
+    u16 dbg_stop_status;
+    u16 window1_page;    /* PROG_PMEM1 or GW1 */
+    u16 window2_page;    /* PROG_PMEM2 or GW2 */
+    u16 window3_page;    /* SHARED or GW3 */
+    u16 io_log_addr;
 };
 
 struct chip_device_regs_t
 {
-    CsrUint16                               gbl_chip_version;
-    CsrUint16                               gbl_misc_enables;
-    CsrUint16                               dbg_emu_cmd;
+    u16                               gbl_chip_version;
+    u16                               gbl_misc_enables;
+    u16                               dbg_emu_cmd;
     struct chip_device_regs_per_transport_t host;
     struct chip_device_regs_per_transport_t spi;
-    CsrUint16                               dbg_reset;
-    CsrUint16                               dbg_reset_value;
-    CsrUint16                               dbg_reset_warn;
-    CsrUint16                               dbg_reset_warn_value;
-    CsrUint16                               dbg_reset_result;
-    CsrUint16                               xap_pch;
-    CsrUint16                               xap_pcl;
-    CsrUint16                               proc_pc_snoop;
-    CsrUint16                               watchdog_disable;
-    CsrUint16                               mailbox0;
-    CsrUint16                               mailbox1;
-    CsrUint16                               mailbox2;
-    CsrUint16                               mailbox3;
-    CsrUint16                               sdio_host_int;
-    CsrUint16                               shared_io_interrupt;
-    CsrUint16                               sdio_hip_handshake;
-    CsrUint16                               coex_status; /* Allows WAPI detection */
+    u16                               dbg_reset;
+    u16                               dbg_reset_value;
+    u16                               dbg_reset_warn;
+    u16                               dbg_reset_warn_value;
+    u16                               dbg_reset_result;
+    u16                               xap_pch;
+    u16                               xap_pcl;
+    u16                               proc_pc_snoop;
+    u16                               watchdog_disable;
+    u16                               mailbox0;
+    u16                               mailbox1;
+    u16                               mailbox2;
+    u16                               mailbox3;
+    u16                               sdio_host_int;
+    u16                               shared_io_interrupt;
+    u16                               sdio_hip_handshake;
+    u16                               coex_status; /* Allows WAPI detection */
 };
 
 /* If allowed is false then this window does not provide this
@@ -119,7 +119,7 @@ struct window_shift_info_t
 {
     CsrInt32  allowed;
     CsrUint32 page_shift;
-    CsrUint16 page_offset;
+    u16 page_offset;
 };
 
 /* Each window has an address and size.  These are obvious.  It then
@@ -129,9 +129,9 @@ struct window_shift_info_t
    are unusable. */
 struct window_info_t
 {
-    CsrUint16                         address;
-    CsrUint16                         size;
-    CsrUint16                         blocked;
+    u16                         address;
+    u16                         size;
+    u16                         blocked;
     const struct window_shift_info_t *mode;
 };
 
@@ -141,8 +141,8 @@ struct window_info_t
 struct chip_version_t
 {
     CsrInt32  pre_bc7;
-    CsrUint16 mask;
-    CsrUint16 result;
+    u16 mask;
+    u16 result;
     u8  sdio;
 };
 
@@ -193,7 +193,7 @@ struct chip_device_desc_t
     /* The offsets into the data address space of interesting things. */
     struct
     {
-        CsrUint16 ram;
+        u16 ram;
         /* maybe add shared / page tables? */
     } data_offset;
 
diff --git a/drivers/staging/csr/csr_wifi_hip_conversions.h b/drivers/staging/csr/csr_wifi_hip_conversions.h
index 212b9b7b105..58a2d724e3f 100644
--- a/drivers/staging/csr/csr_wifi_hip_conversions.h
+++ b/drivers/staging/csr/csr_wifi_hip_conversions.h
@@ -71,7 +71,7 @@ extern "C" {
 
 CsrInt32 get_packed_struct_size(const u8 *buf);
 CsrResult read_unpack_signal(const u8 *ptr, CSR_SIGNAL *sig);
-CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, CsrUint16 *sig_len);
+CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, u16 *sig_len);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_wifi_hip_download.c b/drivers/staging/csr/csr_wifi_hip_download.c
index 4f7dae8b33c..2a3ece304f0 100644
--- a/drivers/staging/csr/csr_wifi_hip_download.c
+++ b/drivers/staging/csr/csr_wifi_hip_download.c
@@ -52,7 +52,7 @@ static CsrResult do_patch_convert_download(card_t *card,
 static CsrResult _find_in_slut(card_t *card, symbol_t *psym, CsrUint32 *pslut)
 {
     CsrUint32 slut_address;
-    CsrUint16 finger_print;
+    u16 finger_print;
     CsrResult r;
     CsrResult csrResult;
 
@@ -121,7 +121,7 @@ static CsrResult _find_in_slut(card_t *card, symbol_t *psym, CsrUint32 *pslut)
 
     while (1)
     {
-        CsrUint16 id;
+        u16 id;
         CsrUint32 obj;
 
         r = unifi_card_read16(card, slut_address, &id);
@@ -500,7 +500,7 @@ void* unifi_dl_fw_read_start(card_t *card, s8 is_fw)
 static CsrResult safe_read_shared_location(card_t *card, CsrUint32 address, u8 *pdata)
 {
     CsrResult r;
-    CsrUint16 limit = 1000;
+    u16 limit = 1000;
     u8 b, b2;
 
     *pdata = 0;
@@ -662,7 +662,7 @@ static CsrResult send_ptdl_to_unifi(card_t *card, void *dlpriv,
     CsrInt32 data_len;
     CsrUint32 write_len;
     CsrResult r;
-    const CsrUint16 buf_size = 2 * 1024;
+    const u16 buf_size = 2 * 1024;
 
     offset = ptdl->dl_offset;
     data_len = ptdl->dl_size;
@@ -757,8 +757,8 @@ static CsrResult do_patch_download(card_t *card, void *dlpriv, xbv1_t *pfwinfo,
 {
     CsrResult r;
     CsrInt32 i;
-    CsrUint16 loader_version;
-    CsrUint16 handle;
+    u16 loader_version;
+    u16 handle;
     CsrUint32 total_bytes;
 
     /*
@@ -795,7 +795,7 @@ static CsrResult do_patch_download(card_t *card, void *dlpriv, xbv1_t *pfwinfo,
     if (card->loader_led_mask)
     {
         r = unifi_card_write16(card, boot_ctrl_addr + 2,
-                               (CsrUint16)card->loader_led_mask);
+                               (u16)card->loader_led_mask);
         if (r != CSR_RESULT_SUCCESS)
         {
             unifi_error(card->ospriv, "Patch download: Failed to write LED mask\n");
diff --git a/drivers/staging/csr/csr_wifi_hip_dump.c b/drivers/staging/csr/csr_wifi_hip_dump.c
index efa699f20dc..fa9b697ad13 100644
--- a/drivers/staging/csr/csr_wifi_hip_dump.c
+++ b/drivers/staging/csr/csr_wifi_hip_dump.c
@@ -38,12 +38,12 @@
 /* Mini-coredump state */
 typedef struct coredump_buf
 {
-    CsrUint16  count;                       /* serial number of dump */
+    u16  count;                       /* serial number of dump */
     CsrTime    timestamp;                   /* host's system time at capture */
     CsrInt16   requestor;                   /* request: 0=auto dump, 1=manual */
-    CsrUint16  chip_ver;
+    u16  chip_ver;
     CsrUint32  fw_ver;
-    CsrUint16 *zone[HIP_CDUMP_NUM_ZONES];
+    u16 *zone[HIP_CDUMP_NUM_ZONES];
 
     struct coredump_buf *next;              /* circular list */
     struct coredump_buf *prev;              /* circular list */
@@ -55,16 +55,16 @@ struct coredump_zone
     unifi_coredump_space_t           space;  /* XAP memory space this zone covers */
     enum unifi_dbg_processors_select cpu;    /* XAP CPU core selector */
     CsrUint32                        gp;     /* Generic Pointer to memory zone on XAP */
-    CsrUint16                        offset; /* 16-bit XAP word offset of zone in memory space */
-    CsrUint16                        length; /* Length of zone in XAP words */
+    u16                        offset; /* 16-bit XAP word offset of zone in memory space */
+    u16                        length; /* Length of zone in XAP words */
 };
 
 static CsrResult unifi_coredump_from_sdio(card_t *card, coredump_buffer *dump_buf);
 static CsrResult unifi_coredump_read_zones(card_t *card, coredump_buffer *dump_buf);
-static CsrResult unifi_coredump_read_zone(card_t *card, CsrUint16 *zone,
+static CsrResult unifi_coredump_read_zone(card_t *card, u16 *zone,
                                           const struct coredump_zone *def);
 static CsrInt32 get_value_from_coredump(const coredump_buffer *dump,
-                                        const unifi_coredump_space_t space, const CsrUint16 offset);
+                                        const unifi_coredump_space_t space, const u16 offset);
 
 /* Table of chip memory zones we capture on mini-coredump */
 static const struct coredump_zone zonedef_table[HIP_CDUMP_NUM_ZONES] = {
@@ -190,7 +190,7 @@ CsrResult unifi_coredump_handle_request(card_t *card)
 CsrResult unifi_coredump_capture(card_t *card, struct unifi_coredump_req *req)
 {
     CsrResult r = CSR_RESULT_SUCCESS;
-    static CsrUint16 dump_seq_no = 1;
+    static u16 dump_seq_no = 1;
     CsrTime time_of_capture;
 
     func_enter();
@@ -295,10 +295,10 @@ done:
  */
 static CsrInt32 get_value_from_coredump(const coredump_buffer       *coreDump,
                                         const unifi_coredump_space_t space,
-                                        const CsrUint16              offset_in_space)
+                                        const u16              offset_in_space)
 {
     CsrInt32 r = -1;
-    CsrUint16 offset_in_zone;
+    u16 offset_in_zone;
     CsrUint32 zone_end_offset;
     CsrInt32 i;
     const struct coredump_zone *def = &zonedef_table[0];
@@ -430,7 +430,7 @@ CsrResult unifi_coredump_get_value(card_t *card, struct unifi_coredump_req *req)
                 req->index, find_dump->count, i);
 
     /* Find the appropriate entry in the buffer */
-    req->value = get_value_from_coredump(find_dump, req->space, (CsrUint16)req->offset);
+    req->value = get_value_from_coredump(find_dump, req->space, (u16)req->offset);
     if (req->value < 0)
     {
         r = CSR_WIFI_HIP_RESULT_RANGE;     /* Un-captured register */
@@ -476,7 +476,7 @@ done:
  *      It is assumed that the caller has already stopped the XAPs
  * ---------------------------------------------------------------------------
  */
-static CsrResult unifi_coredump_read_zone(card_t *card, CsrUint16 *zonebuf, const struct coredump_zone *def)
+static CsrResult unifi_coredump_read_zone(card_t *card, u16 *zonebuf, const struct coredump_zone *def)
 {
     CsrResult r;
 
@@ -508,7 +508,7 @@ static CsrResult unifi_coredump_read_zone(card_t *card, CsrUint16 *zonebuf, cons
                 def->space, def->offset, def->length, def->gp, def->cpu);
 
     /* Read on-chip RAM (byte-wise) */
-    r = unifi_card_readn(card, def->gp, zonebuf, (CsrUint16)(def->length * 2));
+    r = unifi_card_readn(card, def->gp, zonebuf, (u16)(def->length * 2));
     if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
     {
         goto done;
@@ -585,7 +585,7 @@ static CsrResult unifi_coredump_read_zones(card_t *card, coredump_buffer *dump_b
  */
 static CsrResult unifi_coredump_from_sdio(card_t *card, coredump_buffer *dump_buf)
 {
-    CsrUint16 val;
+    u16 val;
     CsrResult r;
     CsrUint32 sdio_addr;
 
@@ -661,7 +661,7 @@ static
 coredump_buffer* new_coredump_node(void *ospriv, coredump_buffer *prevnode)
 {
     coredump_buffer *newnode = NULL;
-    CsrUint16 *newzone = NULL;
+    u16 *newzone = NULL;
     CsrInt32 i;
     CsrUint32 zone_size;
 
@@ -676,8 +676,8 @@ coredump_buffer* new_coredump_node(void *ospriv, coredump_buffer *prevnode)
     /* Allocate chip memory zone capture buffers */
     for (i = 0; i < HIP_CDUMP_NUM_ZONES; i++)
     {
-        zone_size = sizeof(CsrUint16) * zonedef_table[i].length;
-        newzone = (CsrUint16 *)CsrMemAlloc(zone_size);
+        zone_size = sizeof(u16) * zonedef_table[i].length;
+        newzone = (u16 *)CsrMemAlloc(zone_size);
         newnode->zone[i] = newzone;
         if (newzone != NULL)
         {
@@ -738,7 +738,7 @@ coredump_buffer* new_coredump_node(void *ospriv, coredump_buffer *prevnode)
  *      free for capturing.
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_coredump_init(card_t *card, CsrUint16 num_dump_buffers)
+CsrResult unifi_coredump_init(card_t *card, u16 num_dump_buffers)
 {
 #ifndef UNIFI_DISABLE_COREDUMP
     void *ospriv = card->ospriv;
diff --git a/drivers/staging/csr/csr_wifi_hip_packing.c b/drivers/staging/csr/csr_wifi_hip_packing.c
index e024a1fdd85..968926b1a46 100644
--- a/drivers/staging/csr/csr_wifi_hip_packing.c
+++ b/drivers/staging/csr/csr_wifi_hip_packing.c
@@ -38,7 +38,7 @@
 CsrInt32 get_packed_struct_size(const u8 *buf)
 {
     CsrInt32 size = 0;
-    CsrUint16 sig_id;
+    u16 sig_id;
 
     sig_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(buf);
 
@@ -2984,7 +2984,7 @@ CsrResult read_unpack_signal(const u8 *ptr, CSR_SIGNAL *sig)
  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE if the ID of signal was not recognised.
  * ---------------------------------------------------------------------------
  */
-CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, CsrUint16 *sig_len)
+CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, u16 *sig_len)
 {
     CsrInt16 index = 0;
 
diff --git a/drivers/staging/csr/csr_wifi_hip_send.c b/drivers/staging/csr/csr_wifi_hip_send.c
index 96bf40e85fd..5d6b18bd140 100644
--- a/drivers/staging/csr/csr_wifi_hip_send.c
+++ b/drivers/staging/csr/csr_wifi_hip_send.c
@@ -104,7 +104,7 @@ static CsrResult send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
                              const bulk_data_param_t *bulkdata,
                              q_t *sigq, CsrUint32 priority_q, CsrUint32 run_bh)
 {
-    CsrUint16 i, data_slot_size;
+    u16 i, data_slot_size;
     card_signal_t *csptr;
     CsrInt16 qe;
     CsrResult r;
@@ -128,7 +128,7 @@ static CsrResult send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
     csptr = CSR_WIFI_HIP_Q_SLOT_DATA(sigq, qe);
 
     /* Make up the card_signal struct */
-    csptr->signal_length = (CsrUint16)siglen;
+    csptr->signal_length = (u16)siglen;
     CsrMemCpy((void *)csptr->sigbuf, (void *)sigptr, siglen);
 
     for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; ++i)
@@ -307,7 +307,7 @@ CsrResult unifi_send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
                             const bulk_data_param_t *bulkdata)
 {
     q_t *sig_soft_q;
-    CsrUint16 signal_id;
+    u16 signal_id;
     CsrResult r;
     CsrUint32 run_bh;
     CsrUint32 priority_q;
@@ -328,7 +328,7 @@ CsrResult unifi_send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
      */
     if (signal_id == CSR_MA_PACKET_REQUEST_ID)
     {
-        CsrUint16 frame_priority;
+        u16 frame_priority;
 
         if (card->periodic_wake_mode == UNIFI_PERIODIC_WAKE_HOST_ENABLED)
         {
@@ -386,7 +386,7 @@ CsrResult unifi_send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
 CsrResult unifi_send_resources_available(card_t *card, const u8 *sigptr)
 {
     q_t *sig_soft_q;
-    CsrUint16 signal_id = GET_SIGNAL_ID(sigptr);
+    u16 signal_id = GET_SIGNAL_ID(sigptr);
 
     /*
      * If the signal is a CSR_MA_PACKET_REQUEST ,
@@ -394,7 +394,7 @@ CsrResult unifi_send_resources_available(card_t *card, const u8 *sigptr)
      */
     if (signal_id == CSR_MA_PACKET_REQUEST_ID)
     {
-        CsrUint16 frame_priority;
+        u16 frame_priority;
         CsrUint32 priority_q;
 
         /* Map the frame priority to a traffic queue index. */
diff --git a/drivers/staging/csr/csr_wifi_hip_signals.c b/drivers/staging/csr/csr_wifi_hip_signals.c
index 5d0be5397a4..a1b16faafbb 100644
--- a/drivers/staging/csr/csr_wifi_hip_signals.c
+++ b/drivers/staging/csr/csr_wifi_hip_signals.c
@@ -944,7 +944,7 @@ CsrInt32 SigGetDataRefs(CSR_SIGNAL *aSignal, CSR_DATAREF **aDataRef)
 }
 
 
-CsrUint32 SigGetFilterPos(CsrUint16 aSigID)
+CsrUint32 SigGetFilterPos(u16 aSigID)
 {
     switch (aSigID)
     {
diff --git a/drivers/staging/csr/csr_wifi_hip_sigs.h b/drivers/staging/csr/csr_wifi_hip_sigs.h
index 5d04c069b55..a649e14dc70 100644
--- a/drivers/staging/csr/csr_wifi_hip_sigs.h
+++ b/drivers/staging/csr/csr_wifi_hip_sigs.h
@@ -22,13 +22,13 @@ extern "C" {
 
 typedef CsrInt16 csr_place_holding_type;
 
-typedef CsrUint16 CSR_ASSOCIATION_ID;
+typedef u16 CSR_ASSOCIATION_ID;
 
-typedef CsrUint16 CSR_AUTONOMOUS_SCAN_ID;
+typedef u16 CSR_AUTONOMOUS_SCAN_ID;
 
-typedef CsrUint16 CSR_BEACON_PERIODS;
+typedef u16 CSR_BEACON_PERIODS;
 
-typedef CsrUint16 CSR_BLACKOUT_ID;
+typedef u16 CSR_BLACKOUT_ID;
 
 typedef enum CSR_BLACKOUT_SOURCE
 {
@@ -57,9 +57,9 @@ typedef enum CSR_BOOT_LOADER_OPERATION
     CSR_BOOT_LOADER_IMAGE_3                       = 0x13
 } CSR_BOOT_LOADER_OPERATION;
 
-typedef CsrUint16 CSR_CAPABILITY_INFORMATION;
+typedef u16 CSR_CAPABILITY_INFORMATION;
 
-typedef CsrUint16 CSR_CHANNEL_STARTING_FACTOR;
+typedef u16 CSR_CHANNEL_STARTING_FACTOR;
 
 typedef CsrUint32 CSR_CIPHER_SUITE_SELECTOR;
 
@@ -142,11 +142,11 @@ typedef enum CSR_MEMORY_SPACE
     CSR_BT_PROCESSOR_ROM                          = 0x32
 } CSR_MEMORY_SPACE;
 
-typedef CsrUint16 CSR_MICROSECONDS16;
+typedef u16 CSR_MICROSECONDS16;
 
 typedef CsrUint32 CSR_MICROSECONDS32;
 
-typedef CsrUint16 CSR_NATURAL16;
+typedef u16 CSR_NATURAL16;
 
 typedef enum CSR_PS_SCHEME
 {
@@ -161,7 +161,7 @@ typedef enum CSR_PACKET_FILTER_MODE
     CSR_PFM_OPT_IN                                = 0x0003
 } CSR_PACKET_FILTER_MODE;
 
-typedef CsrUint16 CSR_PERIODIC_ID;
+typedef u16 CSR_PERIODIC_ID;
 
 typedef enum CSR_PERIODIC_SCHEDULING_MODE
 {
@@ -344,9 +344,9 @@ typedef enum CSR_SIGNAL_ID
     CSR_DEBUG_GENERIC_INDICATION_ID               = 0x080b
 } CSR_SIGNAL_ID;
 
-typedef CsrUint16 CSR_SIMPLE_POINTER;
+typedef u16 CSR_SIMPLE_POINTER;
 
-typedef CsrUint16 CSR_STARTING_SEQUENCE_NUMBER;
+typedef u16 CSR_STARTING_SEQUENCE_NUMBER;
 
 typedef enum CSR_SYMBOL_ID
 {
@@ -377,7 +377,7 @@ typedef struct CSR_TSF_TIME
     u8 x[8];
 } CSR_TSF_TIME;
 
-typedef CsrUint16 CSR_TIME_UNITS;
+typedef u16 CSR_TIME_UNITS;
 
 typedef enum CSR_TRANSMISSION_CONTROL
 {
@@ -405,9 +405,9 @@ typedef enum CSR_TRANSMISSION_STATUS
     CSR_TX_REJECTED_DTIM_STARTED                  = 0x0010
 } CSR_TRANSMISSION_STATUS;
 
-typedef CsrUint16 CSR_TRIGGER_ID;
+typedef u16 CSR_TRIGGER_ID;
 
-typedef CsrUint16 CSR_TRIGGERED_ID;
+typedef u16 CSR_TRIGGERED_ID;
 
 typedef enum CSR_HIP_VERSIONS
 {
@@ -415,17 +415,17 @@ typedef enum CSR_HIP_VERSIONS
     CSR_HIP_VERSION                               = 0x0900
 } CSR_HIP_VERSIONS;
 
-typedef CsrUint16 CSR_BUFFER_HANDLE;
+typedef u16 CSR_BUFFER_HANDLE;
 
-typedef CsrUint16 CSR_CHANNEL_NUMBER;
+typedef u16 CSR_CHANNEL_NUMBER;
 
 typedef struct CSR_DATA_REFERENCE
 {
-    CsrUint16 SlotNumber;
-    CsrUint16 DataLength;
+    u16 SlotNumber;
+    u16 DataLength;
 } CSR_DATAREF;
 
-typedef CsrUint16 CSR_DIALOG_TOKEN;
+typedef u16 CSR_DIALOG_TOKEN;
 
 typedef struct CSR_GENERIC_POINTER
 {
@@ -574,11 +574,11 @@ typedef struct CSR_MLME_STOP_MEASURE_REQUEST
     CSR_DIALOG_TOKEN DialogToken;
 } CSR_MLME_STOP_MEASURE_REQUEST;
 
-typedef CsrUint16 CSR_PROCESS_ID;
+typedef u16 CSR_PROCESS_ID;
 
-typedef CsrUint16 CSR_RATE;
+typedef u16 CSR_RATE;
 
-typedef CsrUint16 CSR_SEQUENCE_NUMBER;
+typedef u16 CSR_SEQUENCE_NUMBER;
 
 typedef struct CSR_SIGNAL_PRIMITIVE_HEADER
 {
@@ -587,9 +587,9 @@ typedef struct CSR_SIGNAL_PRIMITIVE_HEADER
     CSR_PROCESS_ID SenderProcessId;
 } CSR_SIGNAL_PRIMITIVE_HEADER;
 
-typedef CsrUint16 CSR_TRAFFIC_WINDOW;
+typedef u16 CSR_TRAFFIC_WINDOW;
 
-typedef CsrUint16 CSR_VIF_IDENTIFIER;
+typedef u16 CSR_VIF_IDENTIFIER;
 
 typedef struct CSR_DEBUG_GENERIC_CONFIRM
 {
@@ -1416,7 +1416,7 @@ typedef struct CSR_SIGNAL_PRIMITIVE
 
 #define SIG_FILTER_SIZE 6
 
-CsrUint32 SigGetFilterPos(CsrUint16 aSigID);
+CsrUint32 SigGetFilterPos(u16 aSigID);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_wifi_hip_ta_sampling.c b/drivers/staging/csr/csr_wifi_hip_ta_sampling.c
index 7108cf064f5..1dabd84cb2f 100644
--- a/drivers/staging/csr/csr_wifi_hip_ta_sampling.c
+++ b/drivers/staging/csr/csr_wifi_hip_ta_sampling.c
@@ -97,8 +97,8 @@ static enum ta_frame_identity ta_detect_protocol(card_t *card, CsrWifiRouterCtrl
                                                  const u8 *sta_macaddr)
 {
     ta_data_t *tad = &card->ta_sampling;
-    CsrUint16 proto;
-    CsrUint16 source_port, dest_port;
+    u16 proto;
+    u16 source_port, dest_port;
     CsrWifiMacAddress srcAddress;
     CsrUint32 snap_hdr, oui_hdr;
 
@@ -347,7 +347,7 @@ void unifi_ta_sample(card_t                            *card,
                      const u8                    *saddr,
                      const u8                    *sta_macaddr,
                      CsrUint32                          timestamp,
-                     CsrUint16                          rate)
+                     u16                          rate)
 {
     ta_data_t *tad = &card->ta_sampling;
     enum ta_frame_identity identity;
@@ -530,7 +530,7 @@ CsrResult unifi_ta_configure(card_t                               *card,
  */
 void unifi_ta_classification(card_t                      *card,
                              CsrWifiRouterCtrlTrafficType traffic_type,
-                             CsrUint16                    period)
+                             u16                    period)
 {
     unifi_trace(card->ospriv, UDBG3,
                 "Changed current ta classification to: %d\n", traffic_type);
diff --git a/drivers/staging/csr/csr_wifi_hip_ta_sampling.h b/drivers/staging/csr/csr_wifi_hip_ta_sampling.h
index 602943ecc1b..7183e25e9df 100644
--- a/drivers/staging/csr/csr_wifi_hip_ta_sampling.h
+++ b/drivers/staging/csr/csr_wifi_hip_ta_sampling.h
@@ -42,7 +42,7 @@ typedef struct ta_l4stats
 typedef struct ta_data
 {
     /* Current packet filter configuration */
-    CsrUint16 packet_filter;
+    u16 packet_filter;
 
     /* Current packet custom filter configuration */
     CsrWifiRouterCtrlTrafficFilter custom_filter;
diff --git a/drivers/staging/csr/csr_wifi_hip_udi.c b/drivers/staging/csr/csr_wifi_hip_udi.c
index b7c292c0d6a..72deb2f0b34 100644
--- a/drivers/staging/csr/csr_wifi_hip_udi.c
+++ b/drivers/staging/csr/csr_wifi_hip_udi.c
@@ -45,7 +45,7 @@ CsrInt32 unifi_print_status(card_t *card, CsrCharString *str, CsrInt32 *remain)
 {
     CsrCharString *p = str;
     sdio_config_data_t *cfg;
-    CsrUint16 i, n;
+    u16 i, n;
     CsrInt32 remaining = *remain;
     CsrInt32 written;
 #ifdef CSR_UNSAFE_SDIO_ACCESS
@@ -65,7 +65,7 @@ CsrInt32 unifi_print_status(card_t *card, CsrCharString *str, CsrInt32 *remain)
 
     i = n = 0;
     written = CsrSnprintf(p, remaining, "Chip ID %u\n",
-                          (CsrUint16)card->chip_id);
+                          (u16)card->chip_id);
     UNIFI_SNPRINTF_RET(p, remaining, written);
     written = CsrSnprintf(p, remaining, "Chip Version %04X\n",
                           card->chip_version);
@@ -107,7 +107,7 @@ CsrInt32 unifi_print_status(card_t *card, CsrCharString *str, CsrInt32 *remain)
 
     /* Added by protocol version 0x0001 */
     written = CsrSnprintf(p, remaining, "overlay_size              %u\n",
-                          (CsrUint16)cfg->overlay_size);
+                          (u16)cfg->overlay_size);
     UNIFI_SNPRINTF_RET(p, remaining, written);
 
     /* Added by protocol version 0x0300 */
@@ -134,16 +134,16 @@ CsrInt32 unifi_print_status(card_t *card, CsrCharString *str, CsrInt32 *remain)
     UNIFI_SNPRINTF_RET(p, remaining, written);
 
     written = CsrSnprintf(p, remaining, "fhsr: %u\n",
-                          (CsrUint16)card->from_host_signals_r);
+                          (u16)card->from_host_signals_r);
     UNIFI_SNPRINTF_RET(p, remaining, written);
     written = CsrSnprintf(p, remaining, "fhsw: %u\n",
-                          (CsrUint16)card->from_host_signals_w);
+                          (u16)card->from_host_signals_w);
     UNIFI_SNPRINTF_RET(p, remaining, written);
     written = CsrSnprintf(p, remaining, "thsr: %u\n",
-                          (CsrUint16)card->to_host_signals_r);
+                          (u16)card->to_host_signals_r);
     UNIFI_SNPRINTF_RET(p, remaining, written);
     written = CsrSnprintf(p, remaining, "thsw: %u\n",
-                          (CsrUint16)card->to_host_signals_w);
+                          (u16)card->to_host_signals_w);
     UNIFI_SNPRINTF_RET(p, remaining, written);
     written = CsrSnprintf(p, remaining,
                           "fh buffer contains: %u signals, %u bytes\n",
@@ -189,7 +189,7 @@ CsrInt32 unifi_print_status(card_t *card, CsrCharString *str, CsrInt32 *remain)
     for (i = 0; i < n && card->from_host_data; i++)
     {
         written = CsrSnprintf(p, remaining, " %u",
-                              (CsrUint16)card->from_host_data[i].bd.data_length);
+                              (u16)card->from_host_data[i].bd.data_length);
         UNIFI_SNPRINTF_RET(p, remaining, written);
     }
     written = CsrSnprintf(p, remaining, "\n");
@@ -201,7 +201,7 @@ CsrInt32 unifi_print_status(card_t *card, CsrCharString *str, CsrInt32 *remain)
     for (i = 0; i < n && card->to_host_data; i++)
     {
         written = CsrSnprintf(p, remaining, " %u",
-                              (CsrUint16)card->to_host_data[i].data_length);
+                              (u16)card->to_host_data[i].data_length);
         UNIFI_SNPRINTF_RET(p, remaining, written);
     }
 
diff --git a/drivers/staging/csr/csr_wifi_hip_unifi.h b/drivers/staging/csr/csr_wifi_hip_unifi.h
index 1fb9d769424..cbe600d1b7b 100644
--- a/drivers/staging/csr/csr_wifi_hip_unifi.h
+++ b/drivers/staging/csr/csr_wifi_hip_unifi.h
@@ -148,7 +148,7 @@ typedef struct _bulk_data_desc
 /* Structure of an entry in the Symbol Look Up Table (SLUT). */
 typedef struct _symbol
 {
-    CsrUint16 id;
+    u16 id;
     CsrUint32 obj;
 } symbol_t;
 
@@ -194,10 +194,10 @@ typedef struct _bulk_data_param
  */
 typedef struct _card_info
 {
-    CsrUint16 chip_id;
-    CsrUint16 chip_version;
+    u16 chip_id;
+    u16 chip_version;
     CsrUint32 fw_build;
-    CsrUint16 fw_hip_version;
+    u16 fw_hip_version;
     CsrUint32 sdio_block_size;
 } card_info_t;
 
@@ -514,7 +514,7 @@ void unifi_ta_sample(card_t                            *card,
                      const u8                    *saddr,
                      const u8                    *sta_macaddr,
                      CsrUint32                          timestamp,
-                     CsrUint16                          rate);
+                     u16                          rate);
 
 /**
  * Notify the HIP core lib for a detected Traffic Classification.
@@ -530,7 +530,7 @@ void unifi_ta_sample(card_t                            *card,
  */
 void unifi_ta_classification(card_t                      *card,
                              CsrWifiRouterCtrlTrafficType traffic_type,
-                             CsrUint16                    period);
+                             u16                    period);
 
 #endif
 /**
@@ -545,9 +545,9 @@ void unifi_ta_classification(card_t                      *card,
 CsrResult unifi_card_hard_reset(card_t *card);
 
 
-CsrResult unifi_card_readn(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len);
-CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, CsrUint16 *pdata);
-CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, CsrUint16 data);
+CsrResult unifi_card_readn(card_t *card, CsrUint32 unifi_addr, void *pdata, u16 len);
+CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, u16 *pdata);
+CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, u16 data);
 
 
 enum unifi_dbg_processors_select
@@ -660,15 +660,15 @@ void unifi_receive_event(void *ospriv,
  * @ingroup upperedge
  */
 CsrResult unifi_reque_ma_packet_request(void *ospriv, CsrUint32 host_tag,
-                                        CsrUint16 status,
+                                        u16 status,
                                         bulk_data_desc_t *bulkDataDesc);
 
 #endif
 typedef struct
 {
-    CsrUint16 free_fh_sig_queue_slots[UNIFI_NO_OF_TX_QS];
-    CsrUint16 free_fh_bulkdata_slots;
-    CsrUint16 free_fh_fw_slots;
+    u16 free_fh_sig_queue_slots[UNIFI_NO_OF_TX_QS];
+    u16 free_fh_bulkdata_slots;
+    u16 free_fh_fw_slots;
 } unifi_HipQosInfo;
 
 void unifi_get_hip_qos_info(card_t *card, unifi_HipQosInfo *hipqosinfo);
@@ -859,20 +859,20 @@ void unifi_request_max_sdio_clock(card_t *card);
 
 
 /* Functions to lookup bulk data command names. */
-const CsrCharString* lookup_bulkcmd_name(CsrUint16 id);
+const CsrCharString* lookup_bulkcmd_name(u16 id);
 
 /* Function to log HIP's global debug buffer */
 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
 void unifi_debug_buf_dump(void);
 void unifi_debug_log_to_buf(const CsrCharString *fmt, ...);
-void unifi_debug_hex_to_buf(const CsrCharString *buff, CsrUint16 length);
+void unifi_debug_hex_to_buf(const CsrCharString *buff, u16 length);
 #endif
 
 /* Mini-coredump utility functions */
 CsrResult unifi_coredump_get_value(card_t *card, struct unifi_coredump_req *req);
 CsrResult unifi_coredump_capture(card_t *card, struct unifi_coredump_req *req);
 CsrResult unifi_coredump_request_at_next_reset(card_t *card, s8 enable);
-CsrResult unifi_coredump_init(card_t *card, CsrUint16 num_dump_buffers);
+CsrResult unifi_coredump_init(card_t *card, u16 num_dump_buffers);
 void unifi_coredump_free(card_t *card);
 
 #ifdef __cplusplus
diff --git a/drivers/staging/csr/csr_wifi_hip_unifi_signal_names.c b/drivers/staging/csr/csr_wifi_hip_unifi_signal_names.c
index ee1970dae91..07aa954d5c0 100644
--- a/drivers/staging/csr/csr_wifi_hip_unifi_signal_names.c
+++ b/drivers/staging/csr/csr_wifi_hip_unifi_signal_names.c
@@ -29,7 +29,7 @@ static const struct sig_name Unifi_bulkcmd_names[] = {
     {  15, "Padding" }
 };
 
-const CsrCharString* lookup_bulkcmd_name(CsrUint16 id)
+const CsrCharString* lookup_bulkcmd_name(u16 id)
 {
     if (id < 9)
     {
diff --git a/drivers/staging/csr/csr_wifi_hip_xbv.c b/drivers/staging/csr/csr_wifi_hip_xbv.c
index 8bc79aab702..cc590d79bb2 100644
--- a/drivers/staging/csr/csr_wifi_hip_xbv.c
+++ b/drivers/staging/csr/csr_wifi_hip_xbv.c
@@ -99,7 +99,7 @@ static CsrInt32 xbv_push(xbv1_t *fwinfo, xbv_stack_t *stack,
                          xbv_container new_cont, CsrUint32 ioff);
 
 static CsrUint32 write_uint16(void *buf, const CsrUint32 offset,
-                              const CsrUint16 val);
+                              const u16 val);
 static CsrUint32 write_uint32(void *buf, const CsrUint32 offset,
                               const CsrUint32 val);
 static CsrUint32 write_bytes(void *buf, const CsrUint32 offset,
@@ -109,7 +109,7 @@ static CsrUint32 write_tag(void *buf, const CsrUint32 offset,
 static CsrUint32 write_chunk(void *buf, const CsrUint32 offset,
                              const CsrCharString *tag_str,
                              const CsrUint32 payload_len);
-static CsrUint16 calc_checksum(void *buf, const CsrUint32 offset,
+static u16 calc_checksum(void *buf, const CsrUint32 offset,
                                const CsrUint32 bytes_len);
 static CsrUint32 calc_patch_size(const xbv1_t *fwinfo);
 
@@ -118,7 +118,7 @@ static CsrUint32 write_xbv_header(void *buf, const CsrUint32 offset,
 static CsrUint32 write_ptch_header(void *buf, const CsrUint32 offset,
                                    const CsrUint32 fw_id);
 static CsrUint32 write_patchcmd(void *buf, const CsrUint32 offset,
-                                const CsrUint32 dst_genaddr, const CsrUint16 len);
+                                const CsrUint32 dst_genaddr, const u16 len);
 static CsrUint32 write_reset_ptdl(void *buf, const CsrUint32 offset,
                                   const xbv1_t *fwinfo, CsrUint32 fw_id);
 static CsrUint32 write_fwdl_to_ptdl(void *buf, const CsrUint32 offset,
@@ -361,8 +361,8 @@ CsrResult xbv1_parse(card_t *card, fwreadfn_t readfn, void *dlpriv, xbv1_t *fwin
 
             /* Fill in the VMEQ */
             vmeq->addr = temp[0];
-            vmeq->mask = (CsrUint16)temp[1];
-            vmeq->value = (CsrUint16)temp[2];
+            vmeq->mask = (u16)temp[1];
+            vmeq->value = (u16)temp[2];
         }
         else if (TAG_EQ(tag.t_name, "FWID"))
         {
@@ -568,19 +568,19 @@ static CsrInt32 read_uint(card_t *card, ct_t *ct, CsrUint32 *u, CsrUint32 len)
 } /* read_uint() */
 
 
-static CsrUint32 write_uint16(void *buf, const CsrUint32 offset, const CsrUint16 val)
+static CsrUint32 write_uint16(void *buf, const CsrUint32 offset, const u16 val)
 {
     u8 *dst = (u8 *)buf + offset;
     *dst++ = (u8)(val & 0xff); /* LSB first */
     *dst = (u8)(val >> 8);
-    return sizeof(CsrUint16);
+    return sizeof(u16);
 }
 
 
 static CsrUint32 write_uint32(void *buf, const CsrUint32 offset, const CsrUint32 val)
 {
-    (void)write_uint16(buf, offset + 0, (CsrUint16)(val & 0xffff));
-    (void)write_uint16(buf, offset + 2, (CsrUint16)(val >> 16));
+    (void)write_uint16(buf, offset + 0, (u16)(val & 0xffff));
+    (void)write_uint16(buf, offset + 2, (u16)(val >> 16));
     return sizeof(CsrUint32);
 }
 
@@ -616,18 +616,18 @@ static CsrUint32 write_chunk(void *buf, const CsrUint32 offset, const CsrCharStr
 }
 
 
-static CsrUint16 calc_checksum(void *buf, const CsrUint32 offset, const CsrUint32 bytes_len)
+static u16 calc_checksum(void *buf, const CsrUint32 offset, const CsrUint32 bytes_len)
 {
     CsrUint32 i;
     u8 *src = (u8 *)buf + offset;
-    CsrUint16 sum = 0;
-    CsrUint16 val;
+    u16 sum = 0;
+    u16 val;
 
     for (i = 0; i < bytes_len / 2; i++)
     {
         /* Contents copied to file is LE, host might not be */
-        val = (CsrUint16) * src++;         /* LSB */
-        val += (CsrUint16)(*src++) << 8;   /* MSB */
+        val = (u16) * src++;         /* LSB */
+        val += (u16)(*src++) << 8;   /* MSB */
         sum += val;
     }
 
@@ -711,11 +711,11 @@ static CsrUint32 write_ptch_header(void *buf, const CsrUint32 offset, const CsrU
 #define UF_MEMPUT_MAC  0x0000
 #define UF_MEMPUT_PHY  0x1000
 
-static CsrUint32 write_patchcmd(void *buf, const CsrUint32 offset, const CsrUint32 dst_genaddr, const CsrUint16 len)
+static CsrUint32 write_patchcmd(void *buf, const CsrUint32 offset, const CsrUint32 dst_genaddr, const u16 len)
 {
     CsrUint32 written = 0;
     CsrUint32 region = (dst_genaddr >> 28);
-    CsrUint16 cmd_and_len = UF_MEMPUT_MAC;
+    u16 cmd_and_len = UF_MEMPUT_MAC;
 
     if (region == UF_REGION_PHY)
     {
@@ -731,8 +731,8 @@ static CsrUint32 write_patchcmd(void *buf, const CsrUint32 offset, const CsrUint
     written += write_uint16(buf, offset + written, cmd_and_len);
 
     /* Write the destination generic address */
-    written += write_uint16(buf, offset + written, (CsrUint16)(dst_genaddr >> 16));
-    written += write_uint16(buf, offset + written, (CsrUint16)(dst_genaddr & 0xffff));
+    written += write_uint16(buf, offset + written, (u16)(dst_genaddr >> 16));
+    written += write_uint16(buf, offset + written, (u16)(dst_genaddr & 0xffff));
 
     /* The data payload should be appended to the command */
     return written;
@@ -748,7 +748,7 @@ static CsrUint32 write_fwdl_to_ptdl(void *buf, const CsrUint32 offset, fwreadfn_
     CsrUint32 left = fwdl->dl_size;      /* Bytes left in this fwdl */
     CsrUint32 dl_addr = fwdl->dl_addr;   /* Target address of fwdl image on XAP */
     CsrUint32 dl_offs = fwdl->dl_offset; /* Offset of fwdl image data in source */
-    CsrUint16 csum;
+    u16 csum;
     CsrUint32 csum_start_offs;           /* first offset to include in checksum */
     CsrUint32 sec_data_len;              /* section data byte count */
     CsrUint32 sec_len;                   /* section data + header byte count */
@@ -768,15 +768,15 @@ static CsrUint32 write_fwdl_to_ptdl(void *buf, const CsrUint32 offset, fwreadfn_
         csum_start_offs = offset + written;
 
         /* Patch-chunk header: fw_id. Note that this is in XAP word order */
-        written += write_uint16(buf, offset + written, (CsrUint16)(fw_id >> 16));
-        written += write_uint16(buf, offset + written, (CsrUint16)(fw_id & 0xffff));
+        written += write_uint16(buf, offset + written, (u16)(fw_id >> 16));
+        written += write_uint16(buf, offset + written, (u16)(fw_id & 0xffff));
 
         /* Patch-chunk header: section length in uint16s */
-        written += write_uint16(buf, offset + written, (CsrUint16)(sec_len / 2));
+        written += write_uint16(buf, offset + written, (u16)(sec_len / 2));
 
 
         /* Write the appropriate patch command for the data's destination ptr */
-        written += write_patchcmd(buf, offset + written, dl_addr, (CsrUint16)(sec_data_len / 2));
+        written += write_patchcmd(buf, offset + written, dl_addr, (u16)(sec_data_len / 2));
 
         /* Write the data itself (limited to the max chunk length) */
         if (readfn(NULL, (void *)dlpriv, dl_offs, fw_buf, sec_data_len) < 0)
@@ -789,7 +789,7 @@ static CsrUint32 write_fwdl_to_ptdl(void *buf, const CsrUint32 offset, fwreadfn_
                                fw_buf,
                                sec_data_len);
 
-        /* CsrUint16 checksum calculated over data written */
+        /* u16 checksum calculated over data written */
         csum = calc_checksum(buf, csum_start_offs, written - (csum_start_offs - offset));
         written += write_uint16(buf, offset + written, csum);
 
@@ -813,7 +813,7 @@ static CsrUint32 write_fwdl_to_ptdl(void *buf, const CsrUint32 offset, fwreadfn_
 static CsrUint32 write_reset_ptdl(void *buf, const CsrUint32 offset, const xbv1_t *fwinfo, CsrUint32 fw_id)
 {
     CsrUint32 written = 0;
-    CsrUint16 csum;
+    u16 csum;
     CsrUint32 csum_start_offs;                 /* first offset to include in checksum */
     CsrUint32 sec_len;                         /* section data + header byte count */
 
@@ -826,11 +826,11 @@ static CsrUint32 write_reset_ptdl(void *buf, const CsrUint32 offset, const xbv1_
     csum_start_offs = offset + written;
 
     /* Patch-chunk header: fw_id. Note that this is in XAP word order */
-    written += write_uint16(buf, offset + written, (CsrUint16)(fw_id >> 16));
-    written += write_uint16(buf, offset + written, (CsrUint16)(fw_id & 0xffff));
+    written += write_uint16(buf, offset + written, (u16)(fw_id >> 16));
+    written += write_uint16(buf, offset + written, (u16)(fw_id & 0xffff));
 
     /* Patch-chunk header: section length in uint16s */
-    written += write_uint16(buf, offset + written, (CsrUint16)(sec_len / 2));
+    written += write_uint16(buf, offset + written, (u16)(sec_len / 2));
 
     /*
      * Restart addresses to be executed on subsequent loader restart command.
@@ -846,7 +846,7 @@ static CsrUint32 write_reset_ptdl(void *buf, const CsrUint32 offset, const xbv1_
     written += write_uint16(buf, offset + written, (UF_PHY_START_VEC >> 16));
     written += write_uint16(buf, offset + written, (UF_PHY_START_VEC & 0xffff));
 
-    /* CsrUint16 checksum calculated over data written */
+    /* u16 checksum calculated over data written */
     csum = calc_checksum(buf, csum_start_offs, written - (csum_start_offs - offset));
     written += write_uint16(buf, offset + written, csum);
 
@@ -936,7 +936,7 @@ CsrInt32 xbv1_read_slut(card_t *card, fwreadfn_t readfn, void *dlpriv, xbv1_t *f
             return -1;
         }
 
-        slut[count].id  = (CsrUint16)id;
+        slut[count].id  = (u16)id;
         slut[count].obj = obj;
         count++;
     }
diff --git a/drivers/staging/csr/csr_wifi_hip_xbv.h b/drivers/staging/csr/csr_wifi_hip_xbv.h
index fdc4560676b..f5c3e80b332 100644
--- a/drivers/staging/csr/csr_wifi_hip_xbv.h
+++ b/drivers/staging/csr/csr_wifi_hip_xbv.h
@@ -34,8 +34,8 @@ extern "C" {
 struct VMEQ
 {
     CsrUint32 addr;
-    CsrUint16 mask;
-    CsrUint16 value;
+    u16 mask;
+    u16 value;
 };
 
 struct VAND
diff --git a/drivers/staging/csr/csr_wifi_lib.h b/drivers/staging/csr/csr_wifi_lib.h
index e1ef72b3e48..540d93cc5cc 100644
--- a/drivers/staging/csr/csr_wifi_lib.h
+++ b/drivers/staging/csr/csr_wifi_lib.h
@@ -39,7 +39,7 @@ extern "C" {
  *      Allocates and fills in a message with the signature CsrWifiEvent
  *
  *----------------------------------------------------------------------------*/
-CsrWifiFsmEvent* CsrWifiEvent_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src);
+CsrWifiFsmEvent* CsrWifiEvent_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src);
 
 typedef struct
 {
@@ -55,12 +55,12 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrWifiEventCsrUint8
  *
  *----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint8* CsrWifiEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, u8 value);
+CsrWifiEventCsrUint8* CsrWifiEventCsrUint8_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src, u8 value);
 
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       value;
+    u16       value;
 } CsrWifiEventCsrUint16;
 
 /*----------------------------------------------------------------------------*
@@ -71,7 +71,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrWifiEventCsrUint16
  *
  *----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint16* CsrWifiEventCsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint16 value);
+CsrWifiEventCsrUint16* CsrWifiEventCsrUint16_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src, u16 value);
 
 typedef struct
 {
@@ -87,12 +87,12 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrWifiEventCsrUint32
  *
  *----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint32* CsrWifiEventCsrUint32_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint32 value);
+CsrWifiEventCsrUint32* CsrWifiEventCsrUint32_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint32 value);
 
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       value16;
+    u16       value16;
     u8        value8;
 } CsrWifiEventCsrUint16CsrUint8;
 
@@ -104,7 +104,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrWifiEventCsrUint16CsrUint8
  *
  *----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint16CsrUint8* CsrWifiEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint16 value16, u8 value8);
+CsrWifiEventCsrUint16CsrUint8* CsrWifiEventCsrUint16CsrUint8_struct(u16 primtype, u16 msgtype, CsrSchedQid dst, CsrSchedQid src, u16 value16, u8 value8);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_wifi_msgconv.h b/drivers/staging/csr/csr_wifi_msgconv.h
index 6029a21d573..72da857742a 100644
--- a/drivers/staging/csr/csr_wifi_msgconv.h
+++ b/drivers/staging/csr/csr_wifi_msgconv.h
@@ -21,11 +21,11 @@ extern "C" {
 #endif
 
 
-void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, CsrUint16 v);
+void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, u16 v);
 void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v);
 void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v);
 
-void CsrUint16DesBigEndian(CsrUint16 *v, u8 *buffer, CsrSize *offset);
+void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset);
 void CsrUint24DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset);
 void CsrUint32DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset);
 
diff --git a/drivers/staging/csr/csr_wifi_nme_ap_converter_init.c b/drivers/staging/csr/csr_wifi_nme_ap_converter_init.c
index 83b3727d47d..37574093148 100644
--- a/drivers/staging/csr/csr_wifi_nme_ap_converter_init.c
+++ b/drivers/staging/csr/csr_wifi_nme_ap_converter_init.c
@@ -43,11 +43,11 @@ static CsrMsgConvMsgEntry csrwifinmeap_conv_lut[] = {
     { 0, NULL, NULL, NULL, NULL },
 };
 
-CsrMsgConvMsgEntry* CsrWifiNmeApConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+CsrMsgConvMsgEntry* CsrWifiNmeApConverterLookup(CsrMsgConvMsgEntry *ce, u16 msgType)
 {
     if (msgType & CSR_PRIM_UPSTREAM)
     {
-        CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT;
+        u16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT;
         if (idx < (CSR_WIFI_NME_AP_PRIM_UPSTREAM_COUNT + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT) &&
             csrwifinmeap_conv_lut[idx].msgType == msgType)
         {
diff --git a/drivers/staging/csr/csr_wifi_nme_ap_free_downstream_contents.c b/drivers/staging/csr/csr_wifi_nme_ap_free_downstream_contents.c
index 8a95f3ceeff..68123968ae9 100644
--- a/drivers/staging/csr/csr_wifi_nme_ap_free_downstream_contents.c
+++ b/drivers/staging/csr/csr_wifi_nme_ap_free_downstream_contents.c
@@ -25,7 +25,7 @@
  *      eventClass: only the value CSR_WIFI_NME_AP_PRIM will be handled
  *      message:    the message to free
  *----------------------------------------------------------------------------*/
-void CsrWifiNmeApFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiNmeApFreeDownstreamMessageContents(u16 eventClass, void *message)
 {
     if (eventClass != CSR_WIFI_NME_AP_PRIM)
     {
@@ -65,7 +65,7 @@ void CsrWifiNmeApFreeDownstreamMessageContents(CsrUint16 eventClass, void *messa
                     break;
             }
             {
-                CsrUint16 i3;
+                u16 i3;
                 for (i3 = 0; i3 < p->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
                 {
                     CsrPmemFree(p->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel);
diff --git a/drivers/staging/csr/csr_wifi_nme_ap_free_upstream_contents.c b/drivers/staging/csr/csr_wifi_nme_ap_free_upstream_contents.c
index 7740dc3a40b..d9ebce3e961 100644
--- a/drivers/staging/csr/csr_wifi_nme_ap_free_upstream_contents.c
+++ b/drivers/staging/csr/csr_wifi_nme_ap_free_upstream_contents.c
@@ -25,7 +25,7 @@
  *      eventClass: only the value CSR_WIFI_NME_AP_PRIM will be handled
  *      message:    the message to free
  *----------------------------------------------------------------------------*/
-void CsrWifiNmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiNmeApFreeUpstreamMessageContents(u16 eventClass, void *message)
 {
     if (eventClass != CSR_WIFI_NME_AP_PRIM)
     {
diff --git a/drivers/staging/csr/csr_wifi_nme_ap_lib.h b/drivers/staging/csr/csr_wifi_nme_ap_lib.h
index 2deebdb3877..4523065ef8e 100644
--- a/drivers/staging/csr/csr_wifi_nme_ap_lib.h
+++ b/drivers/staging/csr/csr_wifi_nme_ap_lib.h
@@ -46,7 +46,7 @@ extern "C" {
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_NME_AP upstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiNmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiNmeApFreeUpstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  *  CsrWifiNmeApFreeDownstreamMessageContents
@@ -58,7 +58,7 @@ void CsrWifiNmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_NME_AP downstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiNmeApFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiNmeApFreeDownstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  * Enum to string functions
diff --git a/drivers/staging/csr/csr_wifi_nme_ap_prim.h b/drivers/staging/csr/csr_wifi_nme_ap_prim.h
index 5e08d53982f..616a899b8eb 100644
--- a/drivers/staging/csr/csr_wifi_nme_ap_prim.h
+++ b/drivers/staging/csr/csr_wifi_nme_ap_prim.h
@@ -77,10 +77,10 @@ typedef u8 CsrWifiNmeApPersCredentialType;
 *******************************************************************************/
 typedef struct
 {
-    CsrUint16 apGroupkeyTimeout;
+    u16 apGroupkeyTimeout;
     CsrBool   apStrictGtkRekey;
-    CsrUint16 apGmkTimeout;
-    CsrUint16 apResponseTimeout;
+    u16 apGmkTimeout;
+    u16 apResponseTimeout;
     u8  apRetransLimit;
 } CsrWifiNmeApConfig;
 
@@ -222,7 +222,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent         common;
-    CsrUint16               interfaceTag;
+    u16               interfaceTag;
     CsrWifiSmeWpsDpid       selectedDevicePasswordId;
     CsrWifiSmeWpsConfigType selectedConfigMethod;
     u8                pin[8];
@@ -254,7 +254,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent         common;
-    CsrUint16               interfaceTag;
+    u16               interfaceTag;
     CsrWifiSmeApType        apType;
     CsrBool                 cloakSsid;
     CsrWifiSsid             ssid;
@@ -282,7 +282,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiNmeApStopReq;
 
 /*******************************************************************************
@@ -332,7 +332,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent   common;
-    CsrUint16         interfaceTag;
+    u16         interfaceTag;
     CsrWifiMacAddress staMacAddress;
     CsrBool           keepBlocking;
 } CsrWifiNmeApStaRemoveReq;
@@ -373,7 +373,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiNmeApWpsRegisterCfm;
 
@@ -395,7 +395,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
     CsrWifiSsid     ssid;
 } CsrWifiNmeApStartCfm;
@@ -419,7 +419,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiNmeApStopCfm;
 
@@ -443,7 +443,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent  common;
-    CsrUint16        interfaceTag;
+    u16        interfaceTag;
     CsrWifiSmeApType apType;
     CsrResult        status;
 } CsrWifiNmeApStopInd;
@@ -488,7 +488,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent       common;
-    CsrUint16             interfaceTag;
+    u16             interfaceTag;
     CsrWifiSmeMediaStatus mediaStatus;
     CsrWifiMacAddress     peerMacAddress;
     CsrWifiMacAddress     peerDeviceAddress;
diff --git a/drivers/staging/csr/csr_wifi_nme_ap_serialize.c b/drivers/staging/csr/csr_wifi_nme_ap_serialize.c
index cdf33a68823..b79b8e8da1f 100644
--- a/drivers/staging/csr/csr_wifi_nme_ap_serialize.c
+++ b/drivers/staging/csr/csr_wifi_nme_ap_serialize.c
@@ -32,15 +32,15 @@ CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 104) */
-    bufferSize += 2;  /* CsrUint16 primitive->apConfig.apGroupkeyTimeout */
+    bufferSize += 2;  /* u16 primitive->apConfig.apGroupkeyTimeout */
     bufferSize += 1;  /* CsrBool primitive->apConfig.apStrictGtkRekey */
-    bufferSize += 2;  /* CsrUint16 primitive->apConfig.apGmkTimeout */
-    bufferSize += 2;  /* CsrUint16 primitive->apConfig.apResponseTimeout */
+    bufferSize += 2;  /* u16 primitive->apConfig.apGmkTimeout */
+    bufferSize += 2;  /* u16 primitive->apConfig.apResponseTimeout */
     bufferSize += 1;  /* u8 primitive->apConfig.apRetransLimit */
     bufferSize += 1;  /* CsrWifiSmeApPhySupportMask primitive->apMacConfig.phySupportedBitmap */
-    bufferSize += 2;  /* CsrUint16 primitive->apMacConfig.beaconInterval */
+    bufferSize += 2;  /* u16 primitive->apMacConfig.beaconInterval */
     bufferSize += 1;  /* u8 primitive->apMacConfig.dtimPeriod */
-    bufferSize += 2;  /* CsrUint16 primitive->apMacConfig.maxListenInterval */
+    bufferSize += 2;  /* u16 primitive->apMacConfig.maxListenInterval */
     bufferSize += 1;  /* u8 primitive->apMacConfig.supportedRatesCount */
     bufferSize += 20; /* u8 primitive->apMacConfig.supportedRates[20] */
     bufferSize += 1;  /* CsrWifiSmePreambleType primitive->apMacConfig.preamble */
@@ -48,31 +48,31 @@ CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg)
     bufferSize += 1;  /* CsrWifiSmeCtsProtectionType primitive->apMacConfig.ctsProtectionType */
     bufferSize += 1;  /* CsrBool primitive->apMacConfig.wmmEnabled */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].cwMin */
             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].cwMax */
             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].aifs */
-            bufferSize += 2; /* CsrUint16 primitive->apMacConfig.wmmApParams[i2].txopLimit */
+            bufferSize += 2; /* u16 primitive->apMacConfig.wmmApParams[i2].txopLimit */
             bufferSize += 1; /* CsrBool primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory */
         }
     }
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].cwMin */
             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].cwMax */
             bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].aifs */
-            bufferSize += 2; /* CsrUint16 primitive->apMacConfig.wmmApBcParams[i2].txopLimit */
+            bufferSize += 2; /* u16 primitive->apMacConfig.wmmApBcParams[i2].txopLimit */
             bufferSize += 1; /* CsrBool primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory */
         }
     }
     bufferSize += 1;         /* CsrWifiSmeApAccessType primitive->apMacConfig.accessType */
     bufferSize += 1;         /* u8 primitive->apMacConfig.macAddressListCount */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
         {
             bufferSize += 6; /* u8 primitive->apMacConfig.macAddressList[i2].a[6] */
@@ -93,50 +93,50 @@ u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apGroupkeyTimeout);
+    CsrUint16Ser(ptr, len, (u16) primitive->apConfig.apGroupkeyTimeout);
     CsrUint8Ser(ptr, len, (u8) primitive->apConfig.apStrictGtkRekey);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apGmkTimeout);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apResponseTimeout);
+    CsrUint16Ser(ptr, len, (u16) primitive->apConfig.apGmkTimeout);
+    CsrUint16Ser(ptr, len, (u16) primitive->apConfig.apResponseTimeout);
     CsrUint8Ser(ptr, len, (u8) primitive->apConfig.apRetransLimit);
     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.phySupportedBitmap);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.beaconInterval);
+    CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.beaconInterval);
     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.dtimPeriod);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.maxListenInterval);
+    CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.maxListenInterval);
     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.supportedRatesCount);
-    CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.supportedRates, ((CsrUint16) (20)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.supportedRates, ((u16) (20)));
     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.preamble);
     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.shortSlotTimeEnabled);
     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.ctsProtectionType);
     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmEnabled);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].cwMin);
             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].cwMax);
             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].aifs);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.wmmApParams[i2].txopLimit);
+            CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.wmmApParams[i2].txopLimit);
             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory);
         }
     }
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].cwMin);
             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].cwMax);
             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].aifs);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.wmmApBcParams[i2].txopLimit);
+            CsrUint16Ser(ptr, len, (u16) primitive->apMacConfig.wmmApBcParams[i2].txopLimit);
             CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory);
         }
     }
     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.accessType);
     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.macAddressListCount);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.macAddressList[i2].a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.macAddressList[i2].a, ((u16) (6)));
         }
     }
     CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.greenfieldSupported);
@@ -156,40 +156,40 @@ void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->apConfig.apGroupkeyTimeout, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->apConfig.apGroupkeyTimeout, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->apConfig.apStrictGtkRekey, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->apConfig.apGmkTimeout, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->apConfig.apResponseTimeout, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->apConfig.apGmkTimeout, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->apConfig.apResponseTimeout, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->apConfig.apRetransLimit, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->apMacConfig.phySupportedBitmap, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.beaconInterval, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->apMacConfig.beaconInterval, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->apMacConfig.dtimPeriod, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.maxListenInterval, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->apMacConfig.maxListenInterval, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->apMacConfig.supportedRatesCount, buffer, &offset);
-    CsrMemCpyDes(primitive->apMacConfig.supportedRates, buffer, &offset, ((CsrUint16) (20)));
+    CsrMemCpyDes(primitive->apMacConfig.supportedRates, buffer, &offset, ((u16) (20)));
     CsrUint8Des((u8 *) &primitive->apMacConfig.preamble, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->apMacConfig.shortSlotTimeEnabled, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->apMacConfig.ctsProtectionType, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->apMacConfig.wmmEnabled, buffer, &offset);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].cwMin, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].cwMax, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].aifs, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.wmmApParams[i2].txopLimit, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->apMacConfig.wmmApParams[i2].txopLimit, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory, buffer, &offset);
         }
     }
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMin, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMax, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].aifs, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.wmmApBcParams[i2].txopLimit, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->apMacConfig.wmmApBcParams[i2].txopLimit, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory, buffer, &offset);
         }
     }
@@ -201,10 +201,10 @@ void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, CsrSize length)
         primitive->apMacConfig.macAddressList = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->apMacConfig.macAddressListCount);
     }
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
         {
-            CsrMemCpyDes(primitive->apMacConfig.macAddressList[i2].a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->apMacConfig.macAddressList[i2].a, buffer, &offset, ((u16) (6)));
         }
     }
     CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.greenfieldSupported, buffer, &offset);
@@ -231,7 +231,7 @@ CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiSmeWpsDpid primitive->selectedDevicePasswordId */
     bufferSize += 2; /* CsrWifiSmeWpsConfigType primitive->selectedConfigMethod */
     bufferSize += 8; /* u8 primitive->pin[8] */
@@ -244,10 +244,10 @@ u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->selectedDevicePasswordId);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->selectedConfigMethod);
-    CsrMemCpySer(ptr, len, (const void *) primitive->pin, ((CsrUint16) (8)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->selectedDevicePasswordId);
+    CsrUint16Ser(ptr, len, (u16) primitive->selectedConfigMethod);
+    CsrMemCpySer(ptr, len, (const void *) primitive->pin, ((u16) (8)));
     return(ptr);
 }
 
@@ -259,10 +259,10 @@ void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->selectedDevicePasswordId, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->selectedConfigMethod, buffer, &offset);
-    CsrMemCpyDes(primitive->pin, buffer, &offset, ((CsrUint16) (8)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->selectedDevicePasswordId, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->selectedConfigMethod, buffer, &offset);
+    CsrMemCpyDes(primitive->pin, buffer, &offset, ((u16) (8)));
 
     return primitive;
 }
@@ -274,7 +274,7 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 112) */
-    bufferSize += 2;  /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;  /* u16 primitive->interfaceTag */
     bufferSize += 1;  /* CsrWifiSmeApType primitive->apType */
     bufferSize += 1;  /* CsrBool primitive->cloakSsid */
     bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
@@ -319,11 +319,11 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
             switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
             {
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
-                    bufferSize += 2;                                                                                                                                                                                                                      /* CsrUint16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode */
+                    bufferSize += 2;                                                                                                                                                                                                                      /* u16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode */
                     bufferSize += 32;                                                                                                                                                                                                                     /* u8 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk[32] */
                     break;
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
-                    bufferSize += 2;                                                                                                                                                                                                                      /* CsrUint16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode */
+                    bufferSize += 2;                                                                                                                                                                                                                      /* u16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode */
                     bufferSize += (primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase?CsrStrLen(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase) : 0) + 1; /* CsrCharString* primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase (0 byte len + 1 for NULL Term) */
                     break;
                 default:
@@ -338,7 +338,7 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
     bufferSize += 3; /* u8 primitive->p2pGoParam.operatingChanList.country[3] */
     bufferSize += 1; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryListCount */
     {
-        CsrUint16 i3;
+        u16 i3;
         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
         {
             bufferSize += 1;                                                                                  /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass */
@@ -360,10 +360,10 @@ u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->apType);
     CsrUint8Ser(ptr, len, (u8) primitive->cloakSsid);
-    CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
     CsrUint8Ser(ptr, len, (u8) primitive->ifIndex);
     CsrUint8Ser(ptr, len, (u8) primitive->channel);
@@ -380,18 +380,18 @@ u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg)
                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
                     CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType);
                     CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey);
-                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, ((CsrUint16) (13)));
-                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, ((CsrUint16) (13)));
-                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, ((CsrUint16) (13)));
-                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, ((CsrUint16) (13)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, ((u16) (13)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, ((u16) (13)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, ((u16) (13)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, ((u16) (13)));
                     break;
                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
                     CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType);
                     CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey);
-                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, ((CsrUint16) (5)));
-                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, ((CsrUint16) (5)));
-                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, ((CsrUint16) (5)));
-                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, ((CsrUint16) (5)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, ((u16) (5)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, ((u16) (5)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, ((u16) (5)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, ((u16) (5)));
                     break;
                 default:
                     break;
@@ -399,17 +399,17 @@ u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg)
             break;
         case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
             CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities);
+            CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities);
+            CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities);
             CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase);
             switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
             {
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
-                    CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode);
-                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, ((CsrUint16) (32)));
+                    CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode);
+                    CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, ((u16) (32)));
                     break;
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
-                    CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode);
+                    CsrUint16Ser(ptr, len, (u16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode);
                     CsrCharStringSer(ptr, len, primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase);
                     break;
                 default:
@@ -421,17 +421,17 @@ u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg)
     }
     CsrUint8Ser(ptr, len, (u8) primitive->maxConnections);
     CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.groupCapability);
-    CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.country, ((CsrUint16) (3)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.country, ((u16) (3)));
     CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryListCount);
     {
-        CsrUint16 i3;
+        u16 i3;
         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
         {
             CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass);
             CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
             if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
             {
-                CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, ((CsrUint16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
+                CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, ((u16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
             }
         }
     }
@@ -451,10 +451,10 @@ void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->apType, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->cloakSsid, buffer, &offset);
-    CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+    CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->ifIndex, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->channel, buffer, &offset);
@@ -471,18 +471,18 @@ void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize length)
                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
                     CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType, buffer, &offset);
                     CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey, buffer, &offset);
-                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, buffer, &offset, ((CsrUint16) (13)));
-                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, buffer, &offset, ((CsrUint16) (13)));
-                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, buffer, &offset, ((CsrUint16) (13)));
-                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, buffer, &offset, ((CsrUint16) (13)));
+                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, buffer, &offset, ((u16) (13)));
+                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, buffer, &offset, ((u16) (13)));
+                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, buffer, &offset, ((u16) (13)));
+                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, buffer, &offset, ((u16) (13)));
                     break;
                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
                     CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType, buffer, &offset);
                     CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey, buffer, &offset);
-                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, buffer, &offset, ((CsrUint16) (5)));
-                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, buffer, &offset, ((CsrUint16) (5)));
-                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, buffer, &offset, ((CsrUint16) (5)));
-                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, buffer, &offset, ((CsrUint16) (5)));
+                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, buffer, &offset, ((u16) (5)));
+                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, buffer, &offset, ((u16) (5)));
+                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, buffer, &offset, ((u16) (5)));
+                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, buffer, &offset, ((u16) (5)));
                     break;
                 default:
                     break;
@@ -490,17 +490,17 @@ void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize length)
             break;
         case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
             CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase, buffer, &offset);
             switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
             {
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
-                    CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode, buffer, &offset);
-                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, buffer, &offset, ((CsrUint16) (32)));
+                    CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode, buffer, &offset);
+                    CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, buffer, &offset, ((u16) (32)));
                     break;
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
-                    CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode, buffer, &offset);
+                    CsrUint16Des((u16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode, buffer, &offset);
                     CsrCharStringDes(&primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase, buffer, &offset);
                     break;
                 default:
@@ -512,7 +512,7 @@ void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize length)
     }
     CsrUint8Des((u8 *) &primitive->maxConnections, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->p2pGoParam.groupCapability, buffer, &offset);
-    CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.country, buffer, &offset, ((CsrUint16) (3)));
+    CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.country, buffer, &offset, ((u16) (3)));
     CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryListCount, buffer, &offset);
     primitive->p2pGoParam.operatingChanList.channelEntryList = NULL;
     if (primitive->p2pGoParam.operatingChanList.channelEntryListCount)
@@ -520,7 +520,7 @@ void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize length)
         primitive->p2pGoParam.operatingChanList.channelEntryList = (CsrWifiSmeApP2pOperatingChanEntry *)CsrPmemAlloc(sizeof(CsrWifiSmeApP2pOperatingChanEntry) * primitive->p2pGoParam.operatingChanList.channelEntryListCount);
     }
     {
-        CsrUint16 i3;
+        u16 i3;
         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
         {
             CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass, buffer, &offset);
@@ -528,7 +528,7 @@ void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize length)
             if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
             {
                 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel = (u8 *)CsrPmemAlloc(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
-                CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, buffer, &offset, ((CsrUint16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
+                CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, buffer, &offset, ((u16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
             }
             else
             {
@@ -565,7 +565,7 @@ void CsrWifiNmeApStartReqSerFree(void *voidPrimitivePointer)
             break;
     }
     {
-        CsrUint16 i3;
+        u16 i3;
         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
         {
             CsrPmemFree(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel);
@@ -582,24 +582,24 @@ CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 51) */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
             bufferSize += 1; /* u8 primitive->wmmApParams[i1].cwMin */
             bufferSize += 1; /* u8 primitive->wmmApParams[i1].cwMax */
             bufferSize += 1; /* u8 primitive->wmmApParams[i1].aifs */
-            bufferSize += 2; /* CsrUint16 primitive->wmmApParams[i1].txopLimit */
+            bufferSize += 2; /* u16 primitive->wmmApParams[i1].txopLimit */
             bufferSize += 1; /* CsrBool primitive->wmmApParams[i1].admissionControlMandatory */
         }
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
             bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].cwMin */
             bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].cwMax */
             bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].aifs */
-            bufferSize += 2; /* CsrUint16 primitive->wmmApBcParams[i1].txopLimit */
+            bufferSize += 2; /* u16 primitive->wmmApBcParams[i1].txopLimit */
             bufferSize += 1; /* CsrBool primitive->wmmApBcParams[i1].admissionControlMandatory */
         }
     }
@@ -613,24 +613,24 @@ u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
             CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].cwMin);
             CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].cwMax);
             CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].aifs);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->wmmApParams[i1].txopLimit);
+            CsrUint16Ser(ptr, len, (u16) primitive->wmmApParams[i1].txopLimit);
             CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].admissionControlMandatory);
         }
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
             CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].cwMin);
             CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].cwMax);
             CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].aifs);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->wmmApBcParams[i1].txopLimit);
+            CsrUint16Ser(ptr, len, (u16) primitive->wmmApBcParams[i1].txopLimit);
             CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].admissionControlMandatory);
         }
     }
@@ -646,24 +646,24 @@ void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
             CsrUint8Des((u8 *) &primitive->wmmApParams[i1].cwMin, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->wmmApParams[i1].cwMax, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->wmmApParams[i1].aifs, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->wmmApParams[i1].txopLimit, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->wmmApParams[i1].txopLimit, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->wmmApParams[i1].admissionControlMandatory, buffer, &offset);
         }
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
             CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].cwMin, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].cwMax, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].aifs, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->wmmApBcParams[i1].txopLimit, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->wmmApBcParams[i1].txopLimit, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].admissionControlMandatory, buffer, &offset);
         }
     }
@@ -677,7 +677,7 @@ CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 6; /* u8 primitive->staMacAddress.a[6] */
     bufferSize += 1; /* CsrBool primitive->keepBlocking */
     return bufferSize;
@@ -689,8 +689,8 @@ u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrMemCpySer(ptr, len, (const void *) primitive->staMacAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrMemCpySer(ptr, len, (const void *) primitive->staMacAddress.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->keepBlocking);
     return(ptr);
 }
@@ -703,8 +703,8 @@ void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrMemCpyDes(primitive->staMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrMemCpyDes(primitive->staMacAddress.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->keepBlocking, buffer, &offset);
 
     return primitive;
@@ -716,7 +716,7 @@ CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -727,8 +727,8 @@ u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -740,8 +740,8 @@ void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -752,7 +752,7 @@ CsrSize CsrWifiNmeApStartCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 40) */
-    bufferSize += 2;  /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;  /* u16 primitive->interfaceTag */
     bufferSize += 2;  /* CsrResult primitive->status */
     bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
     bufferSize += 1;  /* u8 primitive->ssid.length */
@@ -765,9 +765,9 @@ u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
     return(ptr);
 }
@@ -780,9 +780,9 @@ void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
 
     return primitive;
@@ -794,7 +794,7 @@ CsrSize CsrWifiNmeApStopCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -805,8 +805,8 @@ u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -818,8 +818,8 @@ void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -830,7 +830,7 @@ CsrSize CsrWifiNmeApStopIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeApType primitive->apType */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
@@ -842,9 +842,9 @@ u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->apType);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -856,9 +856,9 @@ void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->apType, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -869,7 +869,7 @@ CsrSize CsrWifiNmeApStationIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeMediaStatus primitive->mediaStatus */
     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 6; /* u8 primitive->peerDeviceAddress.a[6] */
@@ -882,10 +882,10 @@ u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerDeviceAddress.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerDeviceAddress.a, ((u16) (6)));
     return(ptr);
 }
 
@@ -897,10 +897,10 @@ void* CsrWifiNmeApStationIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrMemCpyDes(primitive->peerDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
+    CsrMemCpyDes(primitive->peerDeviceAddress.a, buffer, &offset, ((u16) (6)));
 
     return primitive;
 }
diff --git a/drivers/staging/csr/csr_wifi_nme_lib.h b/drivers/staging/csr/csr_wifi_nme_lib.h
index d7d3c03c1f3..d539d356f2d 100644
--- a/drivers/staging/csr/csr_wifi_nme_lib.h
+++ b/drivers/staging/csr/csr_wifi_nme_lib.h
@@ -43,7 +43,7 @@ extern "C" {
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_NME upstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiNmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiNmeFreeUpstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  *  CsrWifiNmeFreeDownstreamMessageContents
@@ -55,7 +55,7 @@ void CsrWifiNmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_NME downstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiNmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiNmeFreeDownstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  * Enum to string functions
diff --git a/drivers/staging/csr/csr_wifi_nme_prim.h b/drivers/staging/csr/csr_wifi_nme_prim.h
index 79187bab81c..4aff2916995 100644
--- a/drivers/staging/csr/csr_wifi_nme_prim.h
+++ b/drivers/staging/csr/csr_wifi_nme_prim.h
@@ -67,7 +67,7 @@ typedef void (*CsrWifiNmeFrameFreeFunction)(void *frame);
                    - For future use.
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiNmeAuthMode;
+typedef u16 CsrWifiNmeAuthMode;
 #define CSR_WIFI_NME_AUTH_MODE_80211_OPEN      ((CsrWifiNmeAuthMode) 0x0001)
 #define CSR_WIFI_NME_AUTH_MODE_80211_SHARED    ((CsrWifiNmeAuthMode) 0x0002)
 #define CSR_WIFI_NME_AUTH_MODE_8021X_WPA       ((CsrWifiNmeAuthMode) 0x0004)
@@ -204,7 +204,7 @@ typedef u8 CsrWifiNmeConnectionStatus;
                      FAST/LEAP/TLS/TTLS/PEAP/etc.
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiNmeCredentialType;
+typedef u16 CsrWifiNmeCredentialType;
 #define CSR_WIFI_NME_CREDENTIAL_TYPE_OPEN_SYSTEM       ((CsrWifiNmeCredentialType) 0x0000)
 #define CSR_WIFI_NME_CREDENTIAL_TYPE_WEP64             ((CsrWifiNmeCredentialType) 0x0001)
 #define CSR_WIFI_NME_CREDENTIAL_TYPE_WEP128            ((CsrWifiNmeCredentialType) 0x0002)
@@ -246,7 +246,7 @@ typedef CsrUint16 CsrWifiNmeCredentialType;
                    - EAP-LEAP Method.
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiNmeEapMethod;
+typedef u16 CsrWifiNmeEapMethod;
 #define CSR_WIFI_NME_EAP_METHOD_TLS             ((CsrWifiNmeEapMethod) 0x0001)
 #define CSR_WIFI_NME_EAP_METHOD_TTLS_MSCHAPV2   ((CsrWifiNmeEapMethod) 0x0002)
 #define CSR_WIFI_NME_EAP_METHOD_PEAP_GTC        ((CsrWifiNmeEapMethod) 0x0004)
@@ -290,7 +290,7 @@ typedef CsrUint16 CsrWifiNmeEapMethod;
                    - SMS4 key for broadcast messages.
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiNmeEncryption;
+typedef u16 CsrWifiNmeEncryption;
 #define CSR_WIFI_NME_ENCRYPTION_CIPHER_NONE              ((CsrWifiNmeEncryption) 0x0000)
 #define CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_WEP40    ((CsrWifiNmeEncryption) 0x0001)
 #define CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_WEP104   ((CsrWifiNmeEncryption) 0x0002)
@@ -469,7 +469,7 @@ typedef u8 CsrWifiNmeWmmQosInfo;
     Mask type for use with the values defined by CsrWifiNmeEapMethod.
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiNmeEapMethodMask;
+typedef u16 CsrWifiNmeEapMethodMask;
 /*******************************************************************************
 
   NAME
@@ -479,7 +479,7 @@ typedef CsrUint16 CsrWifiNmeEapMethodMask;
     Mask type for use with the values defined by CsrWifiNmeEncryption
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiNmeEncryptionMask;
+typedef u16 CsrWifiNmeEncryptionMask;
 /*******************************************************************************
 
   NAME
@@ -546,7 +546,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint16      encryptionMode;
+    u16      encryptionMode;
     CsrCharString *passphrase;
 } CsrWifiNmePassphrase;
 
@@ -565,7 +565,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint16 encryptionMode;
+    u16 encryptionMode;
     u8  psk[32];
 } CsrWifiNmePsk;
 
@@ -596,7 +596,7 @@ typedef struct
 {
     CsrUint32 certificateLength;
     u8 *certificate;
-    CsrUint16 privateKeyLength;
+    u16 privateKeyLength;
     u8 *privateKey;
     CsrUint32 caCertificateLength;
     u8 *caCertificate;
@@ -715,7 +715,7 @@ typedef struct
     u8                *clientCertificate;
     CsrUint32                certificateAuthorityCertificateLength;
     u8                *certificateAuthorityCertificate;
-    CsrUint16                privateKeyLength;
+    u16                privateKeyLength;
     u8                *privateKey;
     CsrCharString           *privateKeyPassword;
     CsrUint32                sessionLength;
@@ -1035,7 +1035,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent            common;
-    CsrUint16                  interfaceTag;
+    u16                  interfaceTag;
     u8                   profileIdentitysCount;
     CsrWifiNmeProfileIdentity *profileIdentitys;
 } CsrWifiNmeProfileOrderSetReq;
@@ -1059,7 +1059,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrWifiNmeProfileIdentity profileIdentity;
 } CsrWifiNmeProfileConnectReq;
 
@@ -1087,7 +1087,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent   common;
-    CsrUint16         interfaceTag;
+    u16         interfaceTag;
     u8          pin[8];
     CsrWifiSsid       ssid;
     CsrWifiMacAddress bssid;
@@ -1111,7 +1111,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiNmeWpsCancelReq;
 
 /*******************************************************************************
@@ -1130,7 +1130,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiNmeConnectionStatusGetReq;
 
 /*******************************************************************************
@@ -1361,7 +1361,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiNmeProfileOrderSetCfm;
 
@@ -1397,7 +1397,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrResult                 status;
     u8                  connectAttemptsCount;
     CsrWifiNmeConnectAttempt *connectAttempts;
@@ -1426,7 +1426,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent   common;
-    CsrUint16         interfaceTag;
+    u16         interfaceTag;
     CsrResult         status;
     CsrWifiNmeProfile profile;
 } CsrWifiNmeWpsCfm;
@@ -1448,7 +1448,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiNmeWpsCancelCfm;
 
@@ -1471,7 +1471,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent            common;
-    CsrUint16                  interfaceTag;
+    u16                  interfaceTag;
     CsrResult                  status;
     CsrWifiNmeConnectionStatus connectionStatus;
 } CsrWifiNmeConnectionStatusGetCfm;
@@ -1499,7 +1499,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent   common;
-    CsrUint16         interfaceTag;
+    u16         interfaceTag;
     CsrWifiNmeProfile profile;
 } CsrWifiNmeProfileUpdateInd;
 
@@ -1531,7 +1531,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     u8                  connectAttemptsCount;
     CsrWifiNmeConnectAttempt *connectAttempts;
 } CsrWifiNmeProfileDisconnectInd;
diff --git a/drivers/staging/csr/csr_wifi_router_converter_init.c b/drivers/staging/csr/csr_wifi_router_converter_init.c
index 6ff59c01e14..048b146fe81 100644
--- a/drivers/staging/csr/csr_wifi_router_converter_init.c
+++ b/drivers/staging/csr/csr_wifi_router_converter_init.c
@@ -37,11 +37,11 @@ static CsrMsgConvMsgEntry csrwifirouter_conv_lut[] = {
     { 0, NULL, NULL, NULL, NULL },
 };
 
-CsrMsgConvMsgEntry* CsrWifiRouterConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+CsrMsgConvMsgEntry* CsrWifiRouterConverterLookup(CsrMsgConvMsgEntry *ce, u16 msgType)
 {
     if (msgType & CSR_PRIM_UPSTREAM)
     {
-        CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT;
+        u16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT;
         if (idx < (CSR_WIFI_ROUTER_PRIM_UPSTREAM_COUNT + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT) &&
             csrwifirouter_conv_lut[idx].msgType == msgType)
         {
diff --git a/drivers/staging/csr/csr_wifi_router_ctrl_converter_init.c b/drivers/staging/csr/csr_wifi_router_ctrl_converter_init.c
index 32d0bb632d9..7c3289ab71d 100644
--- a/drivers/staging/csr/csr_wifi_router_ctrl_converter_init.c
+++ b/drivers/staging/csr/csr_wifi_router_ctrl_converter_init.c
@@ -90,11 +90,11 @@ static CsrMsgConvMsgEntry csrwifirouterctrl_conv_lut[] = {
     { 0, NULL, NULL, NULL, NULL },
 };
 
-CsrMsgConvMsgEntry* CsrWifiRouterCtrlConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+CsrMsgConvMsgEntry* CsrWifiRouterCtrlConverterLookup(CsrMsgConvMsgEntry *ce, u16 msgType)
 {
     if (msgType & CSR_PRIM_UPSTREAM)
     {
-        CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT;
+        u16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT;
         if (idx < (CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_COUNT + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT) &&
             csrwifirouterctrl_conv_lut[idx].msgType == msgType)
         {
diff --git a/drivers/staging/csr/csr_wifi_router_ctrl_free_downstream_contents.c b/drivers/staging/csr/csr_wifi_router_ctrl_free_downstream_contents.c
index d161fad8460..2329dc3af8a 100644
--- a/drivers/staging/csr/csr_wifi_router_ctrl_free_downstream_contents.c
+++ b/drivers/staging/csr/csr_wifi_router_ctrl_free_downstream_contents.c
@@ -25,7 +25,7 @@
  *      eventClass: only the value CSR_WIFI_ROUTER_CTRL_PRIM will be handled
  *      message:    the message to free
  *----------------------------------------------------------------------------*/
-void CsrWifiRouterCtrlFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiRouterCtrlFreeDownstreamMessageContents(u16 eventClass, void *message)
 {
     if (eventClass != CSR_WIFI_ROUTER_CTRL_PRIM)
     {
diff --git a/drivers/staging/csr/csr_wifi_router_ctrl_free_upstream_contents.c b/drivers/staging/csr/csr_wifi_router_ctrl_free_upstream_contents.c
index b6bf11d566d..8f1ce3d93e8 100644
--- a/drivers/staging/csr/csr_wifi_router_ctrl_free_upstream_contents.c
+++ b/drivers/staging/csr/csr_wifi_router_ctrl_free_upstream_contents.c
@@ -25,7 +25,7 @@
  *      eventClass: only the value CSR_WIFI_ROUTER_CTRL_PRIM will be handled
  *      message:    the message to free
  *----------------------------------------------------------------------------*/
-void CsrWifiRouterCtrlFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiRouterCtrlFreeUpstreamMessageContents(u16 eventClass, void *message)
 {
     if (eventClass != CSR_WIFI_ROUTER_CTRL_PRIM)
     {
diff --git a/drivers/staging/csr/csr_wifi_router_ctrl_lib.h b/drivers/staging/csr/csr_wifi_router_ctrl_lib.h
index 6c7e9743757..e7117ee0ebd 100644
--- a/drivers/staging/csr/csr_wifi_router_ctrl_lib.h
+++ b/drivers/staging/csr/csr_wifi_router_ctrl_lib.h
@@ -39,7 +39,7 @@ extern "C" {
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_ROUTER_CTRL upstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiRouterCtrlFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiRouterCtrlFreeUpstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  *  CsrWifiRouterCtrlFreeDownstreamMessageContents
@@ -51,7 +51,7 @@ void CsrWifiRouterCtrlFreeUpstreamMessageContents(CsrUint16 eventClass, void *me
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_ROUTER_CTRL downstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiRouterCtrlFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiRouterCtrlFreeDownstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  * Enum to string functions
diff --git a/drivers/staging/csr/csr_wifi_router_ctrl_prim.h b/drivers/staging/csr/csr_wifi_router_ctrl_prim.h
index acf10ef1e77..37ba5ea258e 100644
--- a/drivers/staging/csr/csr_wifi_router_ctrl_prim.h
+++ b/drivers/staging/csr/csr_wifi_router_ctrl_prim.h
@@ -34,8 +34,8 @@ typedef CsrResult (*CsrWifiRouterCtrlRawSdioFirmwareDownload)(CsrUint32 length,
 typedef CsrResult (*CsrWifiRouterCtrlRawSdioReset)(void);
 typedef CsrResult (*CsrWifiRouterCtrlRawSdioCoreDumpPrepare)(CsrBool suspendSme);
 typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteBlockRead)(u8 func, CsrUint32 address, u8 *pdata, CsrUint32 length);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpRead16)(u8 func, CsrUint32 address, CsrUint16 *pdata);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(u8 func, CsrUint32 address, CsrUint16 data);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpRead16)(u8 func, CsrUint32 address, u16 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(u8 func, CsrUint32 address, u16 data);
 
 /*******************************************************************************
 
@@ -114,7 +114,7 @@ typedef u8 CsrWifiRouterCtrlListAction;
                    -
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlLowPowerMode;
+typedef u16 CsrWifiRouterCtrlLowPowerMode;
 #define CSR_WIFI_ROUTER_CTRL_LOW_POWER_MODE_DISABLED   ((CsrWifiRouterCtrlLowPowerMode) 0x0000)
 #define CSR_WIFI_ROUTER_CTRL_LOW_POWER_MODE_ENABLED    ((CsrWifiRouterCtrlLowPowerMode) 0x0001)
 
@@ -203,7 +203,7 @@ typedef u8 CsrWifiRouterCtrlPeerStatus;
                    -
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlPortAction;
+typedef u16 CsrWifiRouterCtrlPortAction;
 #define CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN             ((CsrWifiRouterCtrlPortAction) 0x0000)
 #define CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD   ((CsrWifiRouterCtrlPortAction) 0x0001)
 #define CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_BLOCK     ((CsrWifiRouterCtrlPortAction) 0x0002)
@@ -242,7 +242,7 @@ typedef CsrUint16 CsrWifiRouterCtrlPortAction;
                    -
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlPowersaveType;
+typedef u16 CsrWifiRouterCtrlPowersaveType;
 #define CSR_WIFI_ROUTER_CTRL_AC_BK_PS_INFO_PRESENT    ((CsrWifiRouterCtrlPowersaveType) 0x0001)
 #define CSR_WIFI_ROUTER_CTRL_AC_BE_PS_INFO_PRESENT    ((CsrWifiRouterCtrlPowersaveType) 0x0002)
 #define CSR_WIFI_ROUTER_CTRL_AC_VI_PS_INFO_PRESENT    ((CsrWifiRouterCtrlPowersaveType) 0x0004)
@@ -270,7 +270,7 @@ typedef CsrUint16 CsrWifiRouterCtrlPowersaveType;
                    -
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlProtocolDirection;
+typedef u16 CsrWifiRouterCtrlProtocolDirection;
 #define CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_RX   ((CsrWifiRouterCtrlProtocolDirection) 0x0000)
 #define CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX   ((CsrWifiRouterCtrlProtocolDirection) 0x0001)
 
@@ -290,7 +290,7 @@ typedef CsrUint16 CsrWifiRouterCtrlProtocolDirection;
                    -
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlQoSControl;
+typedef u16 CsrWifiRouterCtrlQoSControl;
 #define CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_OFF        ((CsrWifiRouterCtrlQoSControl) 0x0000)
 #define CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_WMM_ON     ((CsrWifiRouterCtrlQoSControl) 0x0001)
 #define CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_80211_ON   ((CsrWifiRouterCtrlQoSControl) 0x0002)
@@ -336,7 +336,7 @@ typedef u8 CsrWifiRouterCtrlQueueConfig;
                    -
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlTrafficConfigType;
+typedef u16 CsrWifiRouterCtrlTrafficConfigType;
 #define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_RESET    ((CsrWifiRouterCtrlTrafficConfigType) 0x0000)
 #define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_FILTER   ((CsrWifiRouterCtrlTrafficConfigType) 0x0001)
 #define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_CLS      ((CsrWifiRouterCtrlTrafficConfigType) 0x0002)
@@ -367,7 +367,7 @@ typedef CsrUint16 CsrWifiRouterCtrlTrafficConfigType;
                    -
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlTrafficPacketType;
+typedef u16 CsrWifiRouterCtrlTrafficPacketType;
 #define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_NONE       ((CsrWifiRouterCtrlTrafficPacketType) 0x0000)
 #define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_EAPOL      ((CsrWifiRouterCtrlTrafficPacketType) 0x0001)
 #define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP       ((CsrWifiRouterCtrlTrafficPacketType) 0x0002)
@@ -421,7 +421,7 @@ typedef CsrUint32 CsrWifiRouterCtrlPeerRecordHandle;
     CsrWifiRouterCtrlPowersaveType
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlPowersaveTypeMask;
+typedef u16 CsrWifiRouterCtrlPowersaveTypeMask;
 /*******************************************************************************
 
   NAME
@@ -440,7 +440,7 @@ typedef u8 CsrWifiRouterCtrlQueueConfigMask;
   DESCRIPTION
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiRouterCtrlRequestorInfo;
+typedef u16 CsrWifiRouterCtrlRequestorInfo;
 /*******************************************************************************
 
   NAME
@@ -491,7 +491,7 @@ typedef struct
     CsrBool                            wmmOrQosEnabled;
     CsrWifiRouterCtrlPowersaveTypeMask powersaveMode;
     u8                           maxSpLength;
-    CsrUint16                          listenIntervalInTus;
+    u16                          listenIntervalInTus;
 } CsrWifiRouterCtrlStaInfo;
 
 /*******************************************************************************
@@ -582,7 +582,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint16                      packetFilter;
+    u16                      packetFilter;
     CsrWifiRouterCtrlTrafficFilter customFilter;
 } CsrWifiRouterCtrlTrafficConfig;
 
@@ -708,11 +708,11 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       mlmeCommandLength;
+    u16       mlmeCommandLength;
     u8       *mlmeCommand;
-    CsrUint16       dataRef1Length;
+    u16       dataRef1Length;
     u8       *dataRef1;
-    CsrUint16       dataRef2Length;
+    u16       dataRef2Length;
     u8       *dataRef2;
 } CsrWifiRouterCtrlHipReq;
 
@@ -733,7 +733,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrWifiRouterCtrlMediaStatus   mediaStatus;
 } CsrWifiRouterCtrlMediaStatusReq;
@@ -758,7 +758,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrResult                      status;
     CsrWifiRouterCtrlListAction    action;
@@ -786,7 +786,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrWifiRouterCtrlPortAction    uncontrolledPortAction;
     CsrWifiRouterCtrlPortAction    controlledPortAction;
@@ -812,7 +812,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                  common;
-    CsrUint16                        interfaceTag;
+    u16                        interfaceTag;
     CsrWifiRouterCtrlRequestorInfo   clientData;
     CsrWifiRouterCtrlQoSControl      control;
     CsrWifiRouterCtrlQueueConfigMask queueConfig;
@@ -856,9 +856,9 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      tclasLength;
+    u16                      tclasLength;
     u8                      *tclas;
 } CsrWifiRouterCtrlTclasAddReq;
 
@@ -936,9 +936,9 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      tclasLength;
+    u16                      tclasLength;
     u8                      *tclas;
 } CsrWifiRouterCtrlTclasDelReq;
 
@@ -960,10 +960,10 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrWifiRouterCtrlTrafficType   trafficType;
-    CsrUint16                      period;
+    u16                      period;
 } CsrWifiRouterCtrlTrafficClassificationReq;
 
 /*******************************************************************************
@@ -984,7 +984,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                    common;
-    CsrUint16                          interfaceTag;
+    u16                          interfaceTag;
     CsrWifiRouterCtrlRequestorInfo     clientData;
     CsrWifiRouterCtrlTrafficConfigType trafficConfigType;
     CsrWifiRouterCtrlTrafficConfig     config;
@@ -1070,7 +1070,7 @@ typedef struct
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrResult                      status;
-    CsrUint16                      numInterfaceAddress;
+    u16                      numInterfaceAddress;
     CsrWifiMacAddress              stationMacAddress[2];
     CsrWifiRouterCtrlSmeVersions   smeVersions;
     CsrBool                        scheduledInterrupt;
@@ -1092,7 +1092,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
 } CsrWifiRouterCtrlM4TransmitReq;
 
@@ -1122,7 +1122,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrWifiRouterCtrlMode          mode;
     CsrWifiMacAddress              bssid;
@@ -1149,10 +1149,10 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrWifiMacAddress              peerMacAddress;
-    CsrUint16                      associationId;
+    u16                      associationId;
     CsrWifiRouterCtrlStaInfo       staInfo;
 } CsrWifiRouterCtrlPeerAddReq;
 
@@ -1173,7 +1173,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                   common;
-    CsrUint16                         interfaceTag;
+    u16                         interfaceTag;
     CsrWifiRouterCtrlRequestorInfo    clientData;
     CsrWifiRouterCtrlPeerRecordHandle peerRecordHandle;
 } CsrWifiRouterCtrlPeerDelReq;
@@ -1196,7 +1196,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                    common;
-    CsrUint16                          interfaceTag;
+    u16                          interfaceTag;
     CsrWifiRouterCtrlRequestorInfo     clientData;
     CsrWifiRouterCtrlPeerRecordHandle  peerRecordHandle;
     CsrWifiRouterCtrlPowersaveTypeMask powersaveMode;
@@ -1242,14 +1242,14 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                  common;
-    CsrUint16                        interfaceTag;
+    u16                        interfaceTag;
     CsrWifiRouterCtrlRequestorInfo   clientData;
     CsrWifiMacAddress                macAddress;
     CsrWifiRouterCtrlTrafficStreamId trafficStreamID;
     CsrWifiRouterCtrlBlockAckRole    role;
-    CsrUint16                        bufferSize;
-    CsrUint16                        timeout;
-    CsrUint16                        ssn;
+    u16                        bufferSize;
+    u16                        timeout;
+    u16                        ssn;
 } CsrWifiRouterCtrlBlockAckEnableReq;
 
 /*******************************************************************************
@@ -1271,7 +1271,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                  common;
-    CsrUint16                        interfaceTag;
+    u16                        interfaceTag;
     CsrWifiRouterCtrlRequestorInfo   clientData;
     CsrWifiMacAddress                macAddress;
     CsrWifiRouterCtrlTrafficStreamId trafficStreamID;
@@ -1297,10 +1297,10 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
-    CsrUint16       signalLength;
+    u16       interfaceTag;
+    u16       signalLength;
     u8       *signal;
-    CsrUint16       dataLength;
+    u16       dataLength;
     u8       *data;
 } CsrWifiRouterCtrlWapiRxPktReq;
 
@@ -1320,7 +1320,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     u8        status;
 } CsrWifiRouterCtrlWapiMulticastFilterReq;
 
@@ -1340,7 +1340,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     u8        status;
 } CsrWifiRouterCtrlWapiUnicastFilterReq;
 
@@ -1361,8 +1361,8 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
-    CsrUint16       dataLength;
+    u16       interfaceTag;
+    u16       dataLength;
     u8       *data;
 } CsrWifiRouterCtrlWapiUnicastTxPktReq;
 
@@ -1382,7 +1382,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrBool         isWapiConnected;
 } CsrWifiRouterCtrlWapiFilterReq;
 
@@ -1407,11 +1407,11 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       mlmeCommandLength;
+    u16       mlmeCommandLength;
     u8       *mlmeCommand;
-    CsrUint16       dataRef1Length;
+    u16       dataRef1Length;
     u8       *dataRef1;
-    CsrUint16       dataRef2Length;
+    u16       dataRef2Length;
     u8       *dataRef2;
 } CsrWifiRouterCtrlHipInd;
 
@@ -1435,7 +1435,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlListAction    action;
     u8                       setAddressesCount;
     CsrWifiMacAddress             *setAddresses;
@@ -1460,7 +1460,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrResult                      status;
     CsrWifiMacAddress              macAddress;
 } CsrWifiRouterCtrlPortConfigureCfm;
@@ -1525,7 +1525,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrResult                      status;
 } CsrWifiRouterCtrlTclasAddCfm;
 
@@ -1603,7 +1603,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrResult                      status;
 } CsrWifiRouterCtrlTclasDelCfm;
 
@@ -1627,7 +1627,7 @@ typedef struct
 {
     CsrWifiFsmEvent                    common;
     CsrWifiRouterCtrlRequestorInfo     clientData;
-    CsrUint16                          interfaceTag;
+    u16                          interfaceTag;
     CsrWifiRouterCtrlTrafficPacketType packetType;
     CsrWifiRouterCtrlProtocolDirection direction;
     CsrWifiMacAddress                  srcAddress;
@@ -1651,7 +1651,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlTrafficStats  stats;
 } CsrWifiRouterCtrlTrafficSampleInd;
 
@@ -1753,7 +1753,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiMacAddress              peerMacAddress;
 } CsrWifiRouterCtrlM4ReadyToSendInd;
 
@@ -1776,7 +1776,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiMacAddress              peerMacAddress;
     CsrResult                      status;
 } CsrWifiRouterCtrlM4TransmittedInd;
@@ -1800,7 +1800,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiMacAddress              peerMacAddress;
     CsrBool                        unicastPdu;
 } CsrWifiRouterCtrlMicFailureInd;
@@ -1824,7 +1824,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiMacAddress              peerMacAddress;
     CsrWifiRouterCtrlPeerStatus    peerStatus;
 } CsrWifiRouterCtrlConnectedInd;
@@ -1849,7 +1849,7 @@ typedef struct
 {
     CsrWifiFsmEvent                   common;
     CsrWifiRouterCtrlRequestorInfo    clientData;
-    CsrUint16                         interfaceTag;
+    u16                         interfaceTag;
     CsrWifiMacAddress                 peerMacAddress;
     CsrWifiRouterCtrlPeerRecordHandle peerRecordHandle;
     CsrResult                         status;
@@ -1873,7 +1873,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrResult                      status;
 } CsrWifiRouterCtrlPeerDelCfm;
 
@@ -1895,7 +1895,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiMacAddress              peerMacAddress;
 } CsrWifiRouterCtrlUnexpectedFrameInd;
 
@@ -1917,7 +1917,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrResult                      status;
 } CsrWifiRouterCtrlPeerUpdateCfm;
 
@@ -1941,8 +1941,8 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      commandQueueSize;
-    CsrUint16                      trafficQueueSize;
+    u16                      commandQueueSize;
+    u16                      trafficQueueSize;
 } CsrWifiRouterCtrlCapabilitiesCfm;
 
 /*******************************************************************************
@@ -1963,7 +1963,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrResult                      status;
 } CsrWifiRouterCtrlBlockAckEnableCfm;
 
@@ -1985,7 +1985,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrResult                      status;
 } CsrWifiRouterCtrlBlockAckDisableCfm;
 
@@ -2009,7 +2009,7 @@ typedef struct
 {
     CsrWifiFsmEvent                  common;
     CsrWifiRouterCtrlRequestorInfo   clientData;
-    CsrUint16                        interfaceTag;
+    u16                        interfaceTag;
     CsrWifiRouterCtrlTrafficStreamId trafficStreamID;
     CsrWifiMacAddress                peerMacAddress;
     CsrResult                        status;
@@ -2033,7 +2033,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiMacAddress              staAddress;
 } CsrWifiRouterCtrlStaInactiveInd;
 
@@ -2058,10 +2058,10 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
-    CsrUint16                      signalLength;
+    u16                      interfaceTag;
+    u16                      signalLength;
     u8                      *signal;
-    CsrUint16                      dataLength;
+    u16                      dataLength;
     u8                      *data;
 } CsrWifiRouterCtrlWapiRxMicCheckInd;
 
@@ -2084,7 +2084,7 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     CsrWifiRouterCtrlMode          mode;
     CsrResult                      status;
 } CsrWifiRouterCtrlModeSetCfm;
@@ -2108,8 +2108,8 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
-    CsrUint16                      interfaceTag;
-    CsrUint16                      dataLength;
+    u16                      interfaceTag;
+    u16                      dataLength;
     u8                      *data;
 } CsrWifiRouterCtrlWapiUnicastTxEncryptInd;
 
diff --git a/drivers/staging/csr/csr_wifi_router_ctrl_serialize.c b/drivers/staging/csr/csr_wifi_router_ctrl_serialize.c
index 7aa96e365f2..f46a5362462 100644
--- a/drivers/staging/csr/csr_wifi_router_ctrl_serialize.c
+++ b/drivers/staging/csr/csr_wifi_router_ctrl_serialize.c
@@ -41,8 +41,8 @@ u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mode);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->mode);
     CsrUint8Ser(ptr, len, (u8) primitive->wakeHost);
     return(ptr);
 }
@@ -55,8 +55,8 @@ void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mode, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mode, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->wakeHost, buffer, &offset);
 
     return primitive;
@@ -69,11 +69,11 @@ CsrSize CsrWifiRouterCtrlHipReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
-    bufferSize += 2;                            /* CsrUint16 primitive->mlmeCommandLength */
+    bufferSize += 2;                            /* u16 primitive->mlmeCommandLength */
     bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
-    bufferSize += 2;                            /* CsrUint16 primitive->dataRef1Length */
+    bufferSize += 2;                            /* u16 primitive->dataRef1Length */
     bufferSize += primitive->dataRef1Length;    /* u8 primitive->dataRef1 */
-    bufferSize += 2;                            /* CsrUint16 primitive->dataRef2Length */
+    bufferSize += 2;                            /* u16 primitive->dataRef2Length */
     bufferSize += primitive->dataRef2Length;    /* u8 primitive->dataRef2 */
     return bufferSize;
 }
@@ -84,20 +84,20 @@ u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mlmeCommandLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->mlmeCommandLength);
     if (primitive->mlmeCommandLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((CsrUint16) (primitive->mlmeCommandLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((u16) (primitive->mlmeCommandLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef1Length);
+    CsrUint16Ser(ptr, len, (u16) primitive->dataRef1Length);
     if (primitive->dataRef1Length)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((CsrUint16) (primitive->dataRef1Length)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((u16) (primitive->dataRef1Length)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef2Length);
+    CsrUint16Ser(ptr, len, (u16) primitive->dataRef2Length);
     if (primitive->dataRef2Length)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((CsrUint16) (primitive->dataRef2Length)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((u16) (primitive->dataRef2Length)));
     }
     return(ptr);
 }
@@ -110,31 +110,31 @@ void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mlmeCommandLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mlmeCommandLength, buffer, &offset);
     if (primitive->mlmeCommandLength)
     {
         primitive->mlmeCommand = (u8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
-        CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((CsrUint16) (primitive->mlmeCommandLength)));
+        CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((u16) (primitive->mlmeCommandLength)));
     }
     else
     {
         primitive->mlmeCommand = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->dataRef1Length, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->dataRef1Length, buffer, &offset);
     if (primitive->dataRef1Length)
     {
         primitive->dataRef1 = (u8 *)CsrPmemAlloc(primitive->dataRef1Length);
-        CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((CsrUint16) (primitive->dataRef1Length)));
+        CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((u16) (primitive->dataRef1Length)));
     }
     else
     {
         primitive->dataRef1 = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->dataRef2Length, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->dataRef2Length, buffer, &offset);
     if (primitive->dataRef2Length)
     {
         primitive->dataRef2 = (u8 *)CsrPmemAlloc(primitive->dataRef2Length);
-        CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((CsrUint16) (primitive->dataRef2Length)));
+        CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((u16) (primitive->dataRef2Length)));
     }
     else
     {
@@ -160,7 +160,7 @@ CsrSize CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 1; /* CsrWifiRouterCtrlMediaStatus primitive->mediaStatus */
     return bufferSize;
@@ -172,8 +172,8 @@ u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
     CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
     return(ptr);
 }
@@ -186,8 +186,8 @@ void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
 
     return primitive;
@@ -200,13 +200,13 @@ CsrSize CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
     bufferSize += 1; /* u8 primitive->getAddressesCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
         {
             bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
@@ -221,16 +221,16 @@ u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint8Ser(ptr, len, (u8) primitive->getAddressesCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((u16) (6)));
         }
     }
     return(ptr);
@@ -244,9 +244,9 @@ void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->getAddressesCount, buffer, &offset);
     primitive->getAddresses = NULL;
@@ -255,10 +255,10 @@ void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, CsrSize length)
         primitive->getAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->getAddressesCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
         {
-            CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((u16) (6)));
         }
     }
 
@@ -279,7 +279,7 @@ CsrSize CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->uncontrolledPortAction */
     bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->controlledPortAction */
@@ -294,11 +294,11 @@ u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->uncontrolledPortAction);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->controlledPortAction);
-    CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->uncontrolledPortAction);
+    CsrUint16Ser(ptr, len, (u16) primitive->controlledPortAction);
+    CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->setProtection);
     return(ptr);
 }
@@ -311,11 +311,11 @@ void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->uncontrolledPortAction, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->controlledPortAction, buffer, &offset);
-    CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->uncontrolledPortAction, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->controlledPortAction, buffer, &offset);
+    CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->setProtection, buffer, &offset);
 
     return primitive;
@@ -327,7 +327,7 @@ CsrSize CsrWifiRouterCtrlQosControlReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2; /* CsrWifiRouterCtrlQoSControl primitive->control */
     bufferSize += 1; /* CsrWifiRouterCtrlQueueConfigMask primitive->queueConfig */
@@ -340,9 +340,9 @@ u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->control);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->control);
     CsrUint8Ser(ptr, len, (u8) primitive->queueConfig);
     return(ptr);
 }
@@ -355,9 +355,9 @@ void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->control, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->control, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->queueConfig, buffer, &offset);
 
     return primitive;
@@ -380,8 +380,8 @@ u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -393,8 +393,8 @@ void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -406,9 +406,9 @@ CsrSize CsrWifiRouterCtrlTclasAddReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
-    bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                      /* u16 primitive->interfaceTag */
     bufferSize += 2;                      /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2;                      /* CsrUint16 primitive->tclasLength */
+    bufferSize += 2;                      /* u16 primitive->tclasLength */
     bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
     return bufferSize;
 }
@@ -419,12 +419,12 @@ u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->tclasLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->tclasLength);
     if (primitive->tclasLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((CsrUint16) (primitive->tclasLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((u16) (primitive->tclasLength)));
     }
     return(ptr);
 }
@@ -437,13 +437,13 @@ void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->tclasLength, buffer, &offset);
     if (primitive->tclasLength)
     {
         primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
-        CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
+        CsrMemCpyDes(primitive->tclas, buffer, &offset, ((u16) (primitive->tclasLength)));
     }
     else
     {
@@ -478,8 +478,8 @@ u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -491,8 +491,8 @@ void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -504,9 +504,9 @@ CsrSize CsrWifiRouterCtrlTclasDelReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
-    bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                      /* u16 primitive->interfaceTag */
     bufferSize += 2;                      /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2;                      /* CsrUint16 primitive->tclasLength */
+    bufferSize += 2;                      /* u16 primitive->tclasLength */
     bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
     return bufferSize;
 }
@@ -517,12 +517,12 @@ u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->tclasLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->tclasLength);
     if (primitive->tclasLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((CsrUint16) (primitive->tclasLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((u16) (primitive->tclasLength)));
     }
     return(ptr);
 }
@@ -535,13 +535,13 @@ void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->tclasLength, buffer, &offset);
     if (primitive->tclasLength)
     {
         primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
-        CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
+        CsrMemCpyDes(primitive->tclas, buffer, &offset, ((u16) (primitive->tclasLength)));
     }
     else
     {
@@ -565,10 +565,10 @@ CsrSize CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 1; /* CsrWifiRouterCtrlTrafficType primitive->trafficType */
-    bufferSize += 2; /* CsrUint16 primitive->period */
+    bufferSize += 2; /* u16 primitive->period */
     return bufferSize;
 }
 
@@ -578,10 +578,10 @@ u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, CsrSize *len, void *ms
     CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
     CsrUint8Ser(ptr, len, (u8) primitive->trafficType);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->period);
+    CsrUint16Ser(ptr, len, (u16) primitive->period);
     return(ptr);
 }
 
@@ -593,10 +593,10 @@ void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->trafficType, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->period, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->period, buffer, &offset);
 
     return primitive;
 }
@@ -607,10 +607,10 @@ CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 24) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2; /* CsrWifiRouterCtrlTrafficConfigType primitive->trafficConfigType */
-    bufferSize += 2; /* CsrUint16 primitive->config.packetFilter */
+    bufferSize += 2; /* u16 primitive->config.packetFilter */
     bufferSize += 4; /* CsrUint32 primitive->config.customFilter.etherType */
     bufferSize += 1; /* u8 primitive->config.customFilter.ipType */
     bufferSize += 4; /* CsrUint32 primitive->config.customFilter.udpSourcePort */
@@ -624,10 +624,10 @@ u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->trafficConfigType);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->config.packetFilter);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->trafficConfigType);
+    CsrUint16Ser(ptr, len, (u16) primitive->config.packetFilter);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.etherType);
     CsrUint8Ser(ptr, len, (u8) primitive->config.customFilter.ipType);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.udpSourcePort);
@@ -643,10 +643,10 @@ void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->trafficConfigType, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->config.packetFilter, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->trafficConfigType, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->config.packetFilter, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.etherType, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->config.customFilter.ipType, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.udpSourcePort, buffer, &offset);
@@ -674,11 +674,11 @@ u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
     if (primitive->dataLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
     }
     return(ptr);
 }
@@ -691,12 +691,12 @@ void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
         primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
-        CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
     }
     else
     {
@@ -723,9 +723,9 @@ CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 30) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 2; /* CsrUint16 primitive->numInterfaceAddress */
+    bufferSize += 2; /* u16 primitive->numInterfaceAddress */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 2; i1++)
         {
             bufferSize += 6;                                                                            /* u8 primitive->stationMacAddress[i1].a[6] */
@@ -744,14 +744,14 @@ u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->numInterfaceAddress);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->numInterfaceAddress);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 2; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((u16) (6)));
         }
     }
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->smeVersions.firmwarePatch);
@@ -769,14 +769,14 @@ void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->numInterfaceAddress, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->numInterfaceAddress, buffer, &offset);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 2; i1++)
         {
-            CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((u16) (6)));
         }
     }
     CsrUint32Des((CsrUint32 *) &primitive->smeVersions.firmwarePatch, buffer, &offset);
@@ -801,7 +801,7 @@ CsrSize CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     return bufferSize;
 }
@@ -812,8 +812,8 @@ u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
     return(ptr);
 }
 
@@ -825,8 +825,8 @@ void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
 
     return primitive;
 }
@@ -837,7 +837,7 @@ CsrSize CsrWifiRouterCtrlModeSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
     bufferSize += 6; /* u8 primitive->bssid.a[6] */
@@ -852,10 +852,10 @@ u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
     CsrUint8Ser(ptr, len, (u8) primitive->mode);
-    CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->protection);
     CsrUint8Ser(ptr, len, (u8) primitive->intraBssDistEnabled);
     return(ptr);
@@ -869,10 +869,10 @@ void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
-    CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->protection, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->intraBssDistEnabled, buffer, &offset);
 
@@ -885,14 +885,14 @@ CsrSize CsrWifiRouterCtrlPeerAddReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
-    bufferSize += 2; /* CsrUint16 primitive->associationId */
+    bufferSize += 2; /* u16 primitive->associationId */
     bufferSize += 1; /* CsrBool primitive->staInfo.wmmOrQosEnabled */
     bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->staInfo.powersaveMode */
     bufferSize += 1; /* u8 primitive->staInfo.maxSpLength */
-    bufferSize += 2; /* CsrUint16 primitive->staInfo.listenIntervalInTus */
+    bufferSize += 2; /* u16 primitive->staInfo.listenIntervalInTus */
     return bufferSize;
 }
 
@@ -902,14 +902,14 @@ u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->associationId);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->associationId);
     CsrUint8Ser(ptr, len, (u8) primitive->staInfo.wmmOrQosEnabled);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->staInfo.powersaveMode);
+    CsrUint16Ser(ptr, len, (u16) primitive->staInfo.powersaveMode);
     CsrUint8Ser(ptr, len, (u8) primitive->staInfo.maxSpLength);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->staInfo.listenIntervalInTus);
+    CsrUint16Ser(ptr, len, (u16) primitive->staInfo.listenIntervalInTus);
     return(ptr);
 }
 
@@ -921,14 +921,14 @@ void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint16Des((CsrUint16 *) &primitive->associationId, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
+    CsrUint16Des((u16 *) &primitive->associationId, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->staInfo.wmmOrQosEnabled, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->staInfo.powersaveMode, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->staInfo.powersaveMode, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->staInfo.maxSpLength, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->staInfo.listenIntervalInTus, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->staInfo.listenIntervalInTus, buffer, &offset);
 
     return primitive;
 }
@@ -939,7 +939,7 @@ CsrSize CsrWifiRouterCtrlPeerDelReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
     return bufferSize;
@@ -951,8 +951,8 @@ u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
     return(ptr);
 }
@@ -965,8 +965,8 @@ void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
 
     return primitive;
@@ -978,7 +978,7 @@ CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
     bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->powersaveMode */
@@ -991,10 +991,10 @@ u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->powersaveMode);
+    CsrUint16Ser(ptr, len, (u16) primitive->powersaveMode);
     return(ptr);
 }
 
@@ -1006,10 +1006,10 @@ void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->powersaveMode, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->powersaveMode, buffer, &offset);
 
     return primitive;
 }
@@ -1020,14 +1020,14 @@ CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 6; /* u8 primitive->macAddress.a[6] */
     bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
     bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
-    bufferSize += 2; /* CsrUint16 primitive->bufferSize */
-    bufferSize += 2; /* CsrUint16 primitive->timeout */
-    bufferSize += 2; /* CsrUint16 primitive->ssn */
+    bufferSize += 2; /* u16 primitive->bufferSize */
+    bufferSize += 2; /* u16 primitive->timeout */
+    bufferSize += 2; /* u16 primitive->ssn */
     return bufferSize;
 }
 
@@ -1037,14 +1037,14 @@ u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
     CsrUint8Ser(ptr, len, (u8) primitive->role);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->bufferSize);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->timeout);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->ssn);
+    CsrUint16Ser(ptr, len, (u16) primitive->bufferSize);
+    CsrUint16Ser(ptr, len, (u16) primitive->timeout);
+    CsrUint16Ser(ptr, len, (u16) primitive->ssn);
     return(ptr);
 }
 
@@ -1056,14 +1056,14 @@ void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->bufferSize, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->timeout, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->ssn, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->bufferSize, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->timeout, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->ssn, buffer, &offset);
 
     return primitive;
 }
@@ -1074,7 +1074,7 @@ CsrSize CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 6; /* u8 primitive->macAddress.a[6] */
     bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
@@ -1088,9 +1088,9 @@ u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
     CsrUint8Ser(ptr, len, (u8) primitive->role);
     return(ptr);
@@ -1104,9 +1104,9 @@ void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
 
@@ -1120,10 +1120,10 @@ CsrSize CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
-    bufferSize += 2;                       /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 2;                       /* CsrUint16 primitive->signalLength */
+    bufferSize += 2;                       /* u16 primitive->interfaceTag */
+    bufferSize += 2;                       /* u16 primitive->signalLength */
     bufferSize += primitive->signalLength; /* u8 primitive->signal */
-    bufferSize += 2;                       /* CsrUint16 primitive->dataLength */
+    bufferSize += 2;                       /* u16 primitive->dataLength */
     bufferSize += primitive->dataLength;   /* u8 primitive->data */
     return bufferSize;
 }
@@ -1134,16 +1134,16 @@ u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->signalLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->signalLength);
     if (primitive->signalLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((CsrUint16) (primitive->signalLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((u16) (primitive->signalLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
     if (primitive->dataLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
     }
     return(ptr);
 }
@@ -1156,22 +1156,22 @@ void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->signalLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->signalLength, buffer, &offset);
     if (primitive->signalLength)
     {
         primitive->signal = (u8 *)CsrPmemAlloc(primitive->signalLength);
-        CsrMemCpyDes(primitive->signal, buffer, &offset, ((CsrUint16) (primitive->signalLength)));
+        CsrMemCpyDes(primitive->signal, buffer, &offset, ((u16) (primitive->signalLength)));
     }
     else
     {
         primitive->signal = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
         primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
-        CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
     }
     else
     {
@@ -1197,8 +1197,8 @@ CsrSize CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
-    bufferSize += 2;                     /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 2;                     /* CsrUint16 primitive->dataLength */
+    bufferSize += 2;                     /* u16 primitive->interfaceTag */
+    bufferSize += 2;                     /* u16 primitive->dataLength */
     bufferSize += primitive->dataLength; /* u8 primitive->data */
     return bufferSize;
 }
@@ -1209,11 +1209,11 @@ u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
     if (primitive->dataLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
     }
     return(ptr);
 }
@@ -1226,12 +1226,12 @@ void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
         primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
-        CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
     }
     else
     {
@@ -1256,11 +1256,11 @@ CsrSize CsrWifiRouterCtrlHipIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
-    bufferSize += 2;                            /* CsrUint16 primitive->mlmeCommandLength */
+    bufferSize += 2;                            /* u16 primitive->mlmeCommandLength */
     bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
-    bufferSize += 2;                            /* CsrUint16 primitive->dataRef1Length */
+    bufferSize += 2;                            /* u16 primitive->dataRef1Length */
     bufferSize += primitive->dataRef1Length;    /* u8 primitive->dataRef1 */
-    bufferSize += 2;                            /* CsrUint16 primitive->dataRef2Length */
+    bufferSize += 2;                            /* u16 primitive->dataRef2Length */
     bufferSize += primitive->dataRef2Length;    /* u8 primitive->dataRef2 */
     return bufferSize;
 }
@@ -1271,20 +1271,20 @@ u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mlmeCommandLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->mlmeCommandLength);
     if (primitive->mlmeCommandLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((CsrUint16) (primitive->mlmeCommandLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((u16) (primitive->mlmeCommandLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef1Length);
+    CsrUint16Ser(ptr, len, (u16) primitive->dataRef1Length);
     if (primitive->dataRef1Length)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((CsrUint16) (primitive->dataRef1Length)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((u16) (primitive->dataRef1Length)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef2Length);
+    CsrUint16Ser(ptr, len, (u16) primitive->dataRef2Length);
     if (primitive->dataRef2Length)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((CsrUint16) (primitive->dataRef2Length)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((u16) (primitive->dataRef2Length)));
     }
     return(ptr);
 }
@@ -1297,31 +1297,31 @@ void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mlmeCommandLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mlmeCommandLength, buffer, &offset);
     if (primitive->mlmeCommandLength)
     {
         primitive->mlmeCommand = (u8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
-        CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((CsrUint16) (primitive->mlmeCommandLength)));
+        CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((u16) (primitive->mlmeCommandLength)));
     }
     else
     {
         primitive->mlmeCommand = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->dataRef1Length, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->dataRef1Length, buffer, &offset);
     if (primitive->dataRef1Length)
     {
         primitive->dataRef1 = (u8 *)CsrPmemAlloc(primitive->dataRef1Length);
-        CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((CsrUint16) (primitive->dataRef1Length)));
+        CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((u16) (primitive->dataRef1Length)));
     }
     else
     {
         primitive->dataRef1 = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->dataRef2Length, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->dataRef2Length, buffer, &offset);
     if (primitive->dataRef2Length)
     {
         primitive->dataRef2 = (u8 *)CsrPmemAlloc(primitive->dataRef2Length);
-        CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((CsrUint16) (primitive->dataRef2Length)));
+        CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((u16) (primitive->dataRef2Length)));
     }
     else
     {
@@ -1349,11 +1349,11 @@ CsrSize CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
     bufferSize += 1; /* u8 primitive->setAddressesCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
         {
             bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
@@ -1368,15 +1368,15 @@ u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint8Ser(ptr, len, (u8) primitive->setAddressesCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((u16) (6)));
         }
     }
     return(ptr);
@@ -1390,8 +1390,8 @@ void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->setAddressesCount, buffer, &offset);
     primitive->setAddresses = NULL;
@@ -1400,10 +1400,10 @@ void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, CsrSize length)
         primitive->setAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->setAddressesCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
         {
-            CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((u16) (6)));
         }
     }
 
@@ -1425,7 +1425,7 @@ CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 6; /* u8 primitive->macAddress.a[6] */
     return bufferSize;
@@ -1437,10 +1437,10 @@ u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((u16) (6)));
     return(ptr);
 }
 
@@ -1452,10 +1452,10 @@ void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((u16) (6)));
 
     return primitive;
 }
@@ -1478,7 +1478,7 @@ u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
     CsrUint8Ser(ptr, len, (u8) primitive->hardSuspend);
     CsrUint8Ser(ptr, len, (u8) primitive->d3Suspend);
     return(ptr);
@@ -1492,7 +1492,7 @@ void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->hardSuspend, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->d3Suspend, buffer, &offset);
 
@@ -1506,7 +1506,7 @@ CsrSize CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -1517,9 +1517,9 @@ u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -1531,9 +1531,9 @@ void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -1555,8 +1555,8 @@ u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->result);
     return(ptr);
 }
 
@@ -1568,8 +1568,8 @@ void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
 
     return primitive;
 }
@@ -1599,8 +1599,8 @@ u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->result);
     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteRead */
     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteWrite */
     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->firmwareDownload */
@@ -1620,8 +1620,8 @@ void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
     primitive->byteRead = NULL;         /* Special for Function Pointers... */
     offset += 4;
     primitive->byteWrite = NULL;        /* Special for Function Pointers... */
@@ -1649,7 +1649,7 @@ CsrSize CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -1660,9 +1660,9 @@ u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -1674,9 +1674,9 @@ void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -1688,7 +1688,7 @@ CsrSize CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlTrafficPacketType primitive->packetType */
     bufferSize += 2; /* CsrWifiRouterCtrlProtocolDirection primitive->direction */
     bufferSize += 6; /* u8 primitive->srcAddress.a[6] */
@@ -1701,11 +1701,11 @@ u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->packetType);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->direction);
-    CsrMemCpySer(ptr, len, (const void *) primitive->srcAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->packetType);
+    CsrUint16Ser(ptr, len, (u16) primitive->direction);
+    CsrMemCpySer(ptr, len, (const void *) primitive->srcAddress.a, ((u16) (6)));
     return(ptr);
 }
 
@@ -1717,11 +1717,11 @@ void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->packetType, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->direction, buffer, &offset);
-    CsrMemCpyDes(primitive->srcAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->packetType, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->direction, buffer, &offset);
+    CsrMemCpyDes(primitive->srcAddress.a, buffer, &offset, ((u16) (6)));
 
     return primitive;
 }
@@ -1733,7 +1733,7 @@ CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 38) */
     bufferSize += 2;  /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2;  /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;  /* u16 primitive->interfaceTag */
     bufferSize += 4;  /* CsrUint32 primitive->stats.rxMeanRate */
     bufferSize += 4;  /* CsrUint32 primitive->stats.rxFramesNum */
     bufferSize += 4;  /* CsrUint32 primitive->stats.txFramesNum */
@@ -1749,14 +1749,14 @@ u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.rxMeanRate);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.rxFramesNum);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.txFramesNum);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.rxBytesCount);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.txBytesCount);
-    CsrMemCpySer(ptr, len, (const void *) primitive->stats.intervals, ((CsrUint16) (11)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->stats.intervals, ((u16) (11)));
     return(ptr);
 }
 
@@ -1768,14 +1768,14 @@ void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->stats.rxMeanRate, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->stats.rxFramesNum, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->stats.txFramesNum, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->stats.rxBytesCount, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->stats.txBytesCount, buffer, &offset);
-    CsrMemCpyDes(primitive->stats.intervals, buffer, &offset, ((CsrUint16) (11)));
+    CsrMemCpyDes(primitive->stats.intervals, buffer, &offset, ((u16) (11)));
 
     return primitive;
 }
@@ -1804,8 +1804,8 @@ u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipId);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipVersion);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwareBuild);
@@ -1823,8 +1823,8 @@ void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->versions.chipId, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->versions.chipVersion, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->versions.firmwareBuild, buffer, &offset);
@@ -1860,8 +1860,8 @@ u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -1873,8 +1873,8 @@ void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -1886,7 +1886,7 @@ CsrSize CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     return bufferSize;
 }
@@ -1897,9 +1897,9 @@ u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
     return(ptr);
 }
 
@@ -1911,9 +1911,9 @@ void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
 
     return primitive;
 }
@@ -1925,7 +1925,7 @@ CsrSize CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
@@ -1937,10 +1937,10 @@ u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -1952,10 +1952,10 @@ void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -1967,7 +1967,7 @@ CsrSize CsrWifiRouterCtrlMicFailureIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 1; /* CsrBool primitive->unicastPdu */
     return bufferSize;
@@ -1979,9 +1979,9 @@ u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->unicastPdu);
     return(ptr);
 }
@@ -1994,9 +1994,9 @@ void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->unicastPdu, buffer, &offset);
 
     return primitive;
@@ -2009,7 +2009,7 @@ CsrSize CsrWifiRouterCtrlConnectedIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 1; /* CsrWifiRouterCtrlPeerStatus primitive->peerStatus */
     return bufferSize;
@@ -2021,9 +2021,9 @@ u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->peerStatus);
     return(ptr);
 }
@@ -2036,9 +2036,9 @@ void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->peerStatus, buffer, &offset);
 
     return primitive;
@@ -2051,7 +2051,7 @@ CsrSize CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 19) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -2064,11 +2064,11 @@ u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -2080,11 +2080,11 @@ void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
     CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -2096,7 +2096,7 @@ CsrSize CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -2107,9 +2107,9 @@ u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -2121,9 +2121,9 @@ void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -2135,7 +2135,7 @@ CsrSize CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     return bufferSize;
 }
@@ -2146,9 +2146,9 @@ u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
     return(ptr);
 }
 
@@ -2160,9 +2160,9 @@ void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
 
     return primitive;
 }
@@ -2174,7 +2174,7 @@ CsrSize CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -2185,9 +2185,9 @@ u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -2199,9 +2199,9 @@ void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -2213,8 +2213,8 @@ CsrSize CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->commandQueueSize */
-    bufferSize += 2; /* CsrUint16 primitive->trafficQueueSize */
+    bufferSize += 2; /* u16 primitive->commandQueueSize */
+    bufferSize += 2; /* u16 primitive->trafficQueueSize */
     return bufferSize;
 }
 
@@ -2224,9 +2224,9 @@ u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->commandQueueSize);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->trafficQueueSize);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->commandQueueSize);
+    CsrUint16Ser(ptr, len, (u16) primitive->trafficQueueSize);
     return(ptr);
 }
 
@@ -2238,9 +2238,9 @@ void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->commandQueueSize, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->trafficQueueSize, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->commandQueueSize, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->trafficQueueSize, buffer, &offset);
 
     return primitive;
 }
@@ -2252,7 +2252,7 @@ CsrSize CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -2263,9 +2263,9 @@ u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -2277,9 +2277,9 @@ void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -2291,7 +2291,7 @@ CsrSize CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -2302,9 +2302,9 @@ u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -2316,9 +2316,9 @@ void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -2330,7 +2330,7 @@ CsrSize CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 2; /* CsrResult primitive->status */
@@ -2343,11 +2343,11 @@ u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -2359,11 +2359,11 @@ void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -2375,7 +2375,7 @@ CsrSize CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 6; /* u8 primitive->staAddress.a[6] */
     return bufferSize;
 }
@@ -2386,9 +2386,9 @@ u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrMemCpySer(ptr, len, (const void *) primitive->staAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrMemCpySer(ptr, len, (const void *) primitive->staAddress.a, ((u16) (6)));
     return(ptr);
 }
 
@@ -2400,9 +2400,9 @@ void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrMemCpyDes(primitive->staAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrMemCpyDes(primitive->staAddress.a, buffer, &offset, ((u16) (6)));
 
     return primitive;
 }
@@ -2415,10 +2415,10 @@ CsrSize CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2;                       /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2;                       /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 2;                       /* CsrUint16 primitive->signalLength */
+    bufferSize += 2;                       /* u16 primitive->interfaceTag */
+    bufferSize += 2;                       /* u16 primitive->signalLength */
     bufferSize += primitive->signalLength; /* u8 primitive->signal */
-    bufferSize += 2;                       /* CsrUint16 primitive->dataLength */
+    bufferSize += 2;                       /* u16 primitive->dataLength */
     bufferSize += primitive->dataLength;   /* u8 primitive->data */
     return bufferSize;
 }
@@ -2429,17 +2429,17 @@ u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->signalLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->signalLength);
     if (primitive->signalLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((CsrUint16) (primitive->signalLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((u16) (primitive->signalLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
     if (primitive->dataLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
     }
     return(ptr);
 }
@@ -2452,23 +2452,23 @@ void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->signalLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->signalLength, buffer, &offset);
     if (primitive->signalLength)
     {
         primitive->signal = (u8 *)CsrPmemAlloc(primitive->signalLength);
-        CsrMemCpyDes(primitive->signal, buffer, &offset, ((CsrUint16) (primitive->signalLength)));
+        CsrMemCpyDes(primitive->signal, buffer, &offset, ((u16) (primitive->signalLength)));
     }
     else
     {
         primitive->signal = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
         primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
-        CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
     }
     else
     {
@@ -2494,7 +2494,7 @@ CsrSize CsrWifiRouterCtrlModeSetCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
@@ -2506,10 +2506,10 @@ u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->mode);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -2521,10 +2521,10 @@ void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -2537,8 +2537,8 @@ CsrSize CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2;                     /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 2;                     /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 2;                     /* CsrUint16 primitive->dataLength */
+    bufferSize += 2;                     /* u16 primitive->interfaceTag */
+    bufferSize += 2;                     /* u16 primitive->dataLength */
     bufferSize += primitive->dataLength; /* u8 primitive->data */
     return bufferSize;
 }
@@ -2549,12 +2549,12 @@ u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, CsrSize *len, void *msg
     CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->clientData);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->dataLength);
     if (primitive->dataLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
     }
     return(ptr);
 }
@@ -2567,13 +2567,13 @@ void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->clientData, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
         primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
-        CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
     }
     else
     {
diff --git a/drivers/staging/csr/csr_wifi_router_free_downstream_contents.c b/drivers/staging/csr/csr_wifi_router_free_downstream_contents.c
index 9ae6cff640e..24d4ae20990 100644
--- a/drivers/staging/csr/csr_wifi_router_free_downstream_contents.c
+++ b/drivers/staging/csr/csr_wifi_router_free_downstream_contents.c
@@ -25,7 +25,7 @@
  *      eventClass: only the value CSR_WIFI_ROUTER_PRIM will be handled
  *      message:    the message to free
  *----------------------------------------------------------------------------*/
-void CsrWifiRouterFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiRouterFreeDownstreamMessageContents(u16 eventClass, void *message)
 {
     if (eventClass != CSR_WIFI_ROUTER_PRIM)
     {
diff --git a/drivers/staging/csr/csr_wifi_router_free_upstream_contents.c b/drivers/staging/csr/csr_wifi_router_free_upstream_contents.c
index 19d9c23f6dd..2faaaace9da 100644
--- a/drivers/staging/csr/csr_wifi_router_free_upstream_contents.c
+++ b/drivers/staging/csr/csr_wifi_router_free_upstream_contents.c
@@ -25,7 +25,7 @@
  *      eventClass: only the value CSR_WIFI_ROUTER_PRIM will be handled
  *      message:    the message to free
  *----------------------------------------------------------------------------*/
-void CsrWifiRouterFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiRouterFreeUpstreamMessageContents(u16 eventClass, void *message)
 {
     if (eventClass != CSR_WIFI_ROUTER_PRIM)
     {
diff --git a/drivers/staging/csr/csr_wifi_router_lib.h b/drivers/staging/csr/csr_wifi_router_lib.h
index 553e7d36e35..4d1fb2794dc 100644
--- a/drivers/staging/csr/csr_wifi_router_lib.h
+++ b/drivers/staging/csr/csr_wifi_router_lib.h
@@ -39,7 +39,7 @@ extern "C" {
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_ROUTER upstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiRouterFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiRouterFreeUpstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  *  CsrWifiRouterFreeDownstreamMessageContents
@@ -51,7 +51,7 @@ void CsrWifiRouterFreeUpstreamMessageContents(CsrUint16 eventClass, void *messag
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_ROUTER downstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiRouterFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiRouterFreeDownstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  * Enum to string functions
diff --git a/drivers/staging/csr/csr_wifi_router_prim.h b/drivers/staging/csr/csr_wifi_router_prim.h
index 182cbfc3dd3..b05ce1a5fba 100644
--- a/drivers/staging/csr/csr_wifi_router_prim.h
+++ b/drivers/staging/csr/csr_wifi_router_prim.h
@@ -116,7 +116,7 @@ typedef CsrUint32 CsrWifiRouterOui;
                    - See IEEE 802.11 Standard
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiRouterPriority;
+typedef u16 CsrWifiRouterPriority;
 #define CSR_WIFI_ROUTER_PRIORITY_QOS_UP0      ((CsrWifiRouterPriority) 0x0000)
 #define CSR_WIFI_ROUTER_PRIORITY_QOS_UP1      ((CsrWifiRouterPriority) 0x0001)
 #define CSR_WIFI_ROUTER_PRIORITY_QOS_UP2      ((CsrWifiRouterPriority) 0x0002)
@@ -180,9 +180,9 @@ typedef CsrUint16 CsrWifiRouterPriority;
 typedef struct
 {
     CsrWifiFsmEvent            common;
-    CsrUint16                  interfaceTag;
+    u16                  interfaceTag;
     CsrWifiRouterEncapsulation encapsulation;
-    CsrUint16                  protocol;
+    u16                  protocol;
     CsrUint32                  oui;
 } CsrWifiRouterMaPacketSubscribeReq;
 
@@ -203,7 +203,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     u8        subscriptionHandle;
 } CsrWifiRouterMaPacketUnsubscribeReq;
 
@@ -242,9 +242,9 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     u8                       subscriptionHandle;
-    CsrUint16                      frameLength;
+    u16                      frameLength;
     u8                      *frame;
     CsrWifiRouterFrameFreeFunction freeFunction;
     CsrWifiRouterPriority          priority;
@@ -271,7 +271,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     u8        subscriptionHandle;
     CsrResult       result;
 } CsrWifiRouterMaPacketRes;
@@ -304,7 +304,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent       common;
-    CsrUint16             interfaceTag;
+    u16             interfaceTag;
     CsrUint32             hostTag;
     CsrWifiRouterPriority priority;
     CsrWifiMacAddress     peerMacAddress;
@@ -331,10 +331,10 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     u8        subscriptionHandle;
     CsrResult       status;
-    CsrUint16       allocOffset;
+    u16       allocOffset;
 } CsrWifiRouterMaPacketSubscribeCfm;
 
 /*******************************************************************************
@@ -355,7 +355,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiRouterMaPacketUnsubscribeCfm;
 
@@ -379,10 +379,10 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       result;
     CsrUint32       hostTag;
-    CsrUint16       rate;
+    u16       rate;
 } CsrWifiRouterMaPacketCfm;
 
 /*******************************************************************************
@@ -410,15 +410,15 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent                common;
-    CsrUint16                      interfaceTag;
+    u16                      interfaceTag;
     u8                       subscriptionHandle;
     CsrResult                      result;
-    CsrUint16                      frameLength;
+    u16                      frameLength;
     u8                      *frame;
     CsrWifiRouterFrameFreeFunction freeFunction;
     CsrInt16                       rssi;
     CsrInt16                       snr;
-    CsrUint16                      rate;
+    u16                      rate;
 } CsrWifiRouterMaPacketInd;
 
 
diff --git a/drivers/staging/csr/csr_wifi_router_serialize.c b/drivers/staging/csr/csr_wifi_router_serialize.c
index e744db885b8..e488564782e 100644
--- a/drivers/staging/csr/csr_wifi_router_serialize.c
+++ b/drivers/staging/csr/csr_wifi_router_serialize.c
@@ -29,9 +29,9 @@ CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiRouterEncapsulation primitive->encapsulation */
-    bufferSize += 2; /* CsrUint16 primitive->protocol */
+    bufferSize += 2; /* u16 primitive->protocol */
     bufferSize += 4; /* CsrUint32 primitive->oui */
     return bufferSize;
 }
@@ -42,9 +42,9 @@ u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->encapsulation);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->protocol);
+    CsrUint16Ser(ptr, len, (u16) primitive->protocol);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->oui);
     return(ptr);
 }
@@ -57,9 +57,9 @@ void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->encapsulation, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->protocol, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->protocol, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->oui, buffer, &offset);
 
     return primitive;
@@ -72,9 +72,9 @@ CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 20) */
-    bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                      /* u16 primitive->interfaceTag */
     bufferSize += 1;                      /* u8 primitive->subscriptionHandle */
-    bufferSize += 2;                      /* CsrUint16 primitive->frameLength */
+    bufferSize += 2;                      /* u16 primitive->frameLength */
     bufferSize += primitive->frameLength; /* u8 primitive->frame */
     bufferSize += 4;                      /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
     bufferSize += 2;                      /* CsrWifiRouterPriority primitive->priority */
@@ -89,15 +89,15 @@ u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->frameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->frameLength);
     if (primitive->frameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((CsrUint16) (primitive->frameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((u16) (primitive->frameLength)));
     }
     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->priority);
+    CsrUint16Ser(ptr, len, (u16) primitive->priority);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
     CsrUint8Ser(ptr, len, (u8) primitive->cfmRequested);
     return(ptr);
@@ -111,13 +111,13 @@ void* CsrWifiRouterMaPacketReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->frameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->frameLength, buffer, &offset);
     if (primitive->frameLength)
     {
         primitive->frame = (u8 *)CsrPmemAlloc(primitive->frameLength);
-        CsrMemCpyDes(primitive->frame, buffer, &offset, ((CsrUint16) (primitive->frameLength)));
+        CsrMemCpyDes(primitive->frame, buffer, &offset, ((u16) (primitive->frameLength)));
     }
     else
     {
@@ -125,7 +125,7 @@ void* CsrWifiRouterMaPacketReqDes(u8 *buffer, CsrSize length)
     }
     primitive->freeFunction = NULL; /* Special for Function Pointers... */
     offset += 4;
-    CsrUint16Des((CsrUint16 *) &primitive->priority, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->priority, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->cfmRequested, buffer, &offset);
 
@@ -146,7 +146,7 @@ CsrSize CsrWifiRouterMaPacketResSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* u8 primitive->subscriptionHandle */
     bufferSize += 2; /* CsrResult primitive->result */
     return bufferSize;
@@ -158,9 +158,9 @@ u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+    CsrUint16Ser(ptr, len, (u16) primitive->result);
     return(ptr);
 }
 
@@ -172,9 +172,9 @@ void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
 
     return primitive;
 }
@@ -185,7 +185,7 @@ CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 4; /* CsrUint32 primitive->hostTag */
     bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
     bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
@@ -198,10 +198,10 @@ u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->priority);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->priority);
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
     return(ptr);
 }
 
@@ -213,10 +213,10 @@ void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->priority, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->priority, buffer, &offset);
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
 
     return primitive;
 }
@@ -227,10 +227,10 @@ CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* u8 primitive->subscriptionHandle */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 2; /* CsrUint16 primitive->allocOffset */
+    bufferSize += 2; /* u16 primitive->allocOffset */
     return bufferSize;
 }
 
@@ -240,10 +240,10 @@ u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->allocOffset);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->allocOffset);
     return(ptr);
 }
 
@@ -255,10 +255,10 @@ void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->allocOffset, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->allocOffset, buffer, &offset);
 
     return primitive;
 }
@@ -269,7 +269,7 @@ CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -280,8 +280,8 @@ u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -293,8 +293,8 @@ void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -305,10 +305,10 @@ CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->result */
     bufferSize += 4; /* CsrUint32 primitive->hostTag */
-    bufferSize += 2; /* CsrUint16 primitive->rate */
+    bufferSize += 2; /* u16 primitive->rate */
     return bufferSize;
 }
 
@@ -318,10 +318,10 @@ u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->result);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->rate);
+    CsrUint16Ser(ptr, len, (u16) primitive->rate);
     return(ptr);
 }
 
@@ -333,10 +333,10 @@ void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->rate, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->rate, buffer, &offset);
 
     return primitive;
 }
@@ -348,15 +348,15 @@ CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
-    bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                      /* u16 primitive->interfaceTag */
     bufferSize += 1;                      /* u8 primitive->subscriptionHandle */
     bufferSize += 2;                      /* CsrResult primitive->result */
-    bufferSize += 2;                      /* CsrUint16 primitive->frameLength */
+    bufferSize += 2;                      /* u16 primitive->frameLength */
     bufferSize += primitive->frameLength; /* u8 primitive->frame */
     bufferSize += 4;                      /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
     bufferSize += 2;                      /* CsrInt16 primitive->rssi */
     bufferSize += 2;                      /* CsrInt16 primitive->snr */
-    bufferSize += 2;                      /* CsrUint16 primitive->rate */
+    bufferSize += 2;                      /* u16 primitive->rate */
     return bufferSize;
 }
 
@@ -366,18 +366,18 @@ u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->frameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->result);
+    CsrUint16Ser(ptr, len, (u16) primitive->frameLength);
     if (primitive->frameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((CsrUint16) (primitive->frameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((u16) (primitive->frameLength)));
     }
     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->rssi);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->snr);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->rate);
+    CsrUint16Ser(ptr, len, (u16) primitive->rssi);
+    CsrUint16Ser(ptr, len, (u16) primitive->snr);
+    CsrUint16Ser(ptr, len, (u16) primitive->rate);
     return(ptr);
 }
 
@@ -389,14 +389,14 @@ void* CsrWifiRouterMaPacketIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->frameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->result, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->frameLength, buffer, &offset);
     if (primitive->frameLength)
     {
         primitive->frame = (u8 *)CsrPmemAlloc(primitive->frameLength);
-        CsrMemCpyDes(primitive->frame, buffer, &offset, ((CsrUint16) (primitive->frameLength)));
+        CsrMemCpyDes(primitive->frame, buffer, &offset, ((u16) (primitive->frameLength)));
     }
     else
     {
@@ -404,9 +404,9 @@ void* CsrWifiRouterMaPacketIndDes(u8 *buffer, CsrSize length)
     }
     primitive->freeFunction = NULL; /* Special for Function Pointers... */
     offset += 4;
-    CsrUint16Des((CsrUint16 *) &primitive->rssi, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->snr, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->rate, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->rssi, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->snr, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->rate, buffer, &offset);
 
     return primitive;
 }
diff --git a/drivers/staging/csr/csr_wifi_router_transport.c b/drivers/staging/csr/csr_wifi_router_transport.c
index 45bee240deb..3247b5890f6 100644
--- a/drivers/staging/csr/csr_wifi_router_transport.c
+++ b/drivers/staging/csr/csr_wifi_router_transport.c
@@ -64,10 +64,10 @@ void CsrWifiRouterTransportDeinit(unifi_priv_t *priv)
 void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLength)
 {
     CsrMsgConvMsgEntry* msgEntry;
-    CsrUint16 primType;
+    u16 primType;
     CsrSchedQid src;
     CsrSchedQid dest;
-    CsrUint16 msgType;
+    u16 msgType;
     CsrSize offset = 0;
     CsrWifiFsmEvent* msg;
 
@@ -96,13 +96,13 @@ void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLe
 
         if (req.dataRef1Length)
         {
-            CsrUint16 dr1Offset = (bufferLength - req.dataRef2Length) - req.dataRef1Length;
+            u16 dr1Offset = (bufferLength - req.dataRef2Length) - req.dataRef1Length;
             req.dataRef1 = &buffer[dr1Offset];
         }
 
         if (req.dataRef2Length)
         {
-            CsrUint16 dr2Offset = bufferLength - req.dataRef2Length;
+            u16 dr2Offset = bufferLength - req.dataRef2Length;
             req.dataRef2 = &buffer[dr2Offset];
         }
 
@@ -159,7 +159,7 @@ void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLe
     CsrPmemFree(msg);
 }
 
-static void CsrWifiRouterTransportSerialiseAndSend(CsrUint16 primType, void* msg)
+static void CsrWifiRouterTransportSerialiseAndSend(u16 primType, void* msg)
 {
     CsrWifiFsmEvent* evt = (CsrWifiFsmEvent*)msg;
     CsrMsgConvMsgEntry* msgEntry;
@@ -198,9 +198,9 @@ static void CsrWifiRouterTransportSerialiseAndSend(CsrUint16 primType, void* msg
 }
 
 #if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
-void CsrSchedMessagePutStringLog(CsrSchedQid q, CsrUint16 mi, void *mv, CsrUint32 line, CsrCharString *file)
+void CsrSchedMessagePutStringLog(CsrSchedQid q, u16 mi, void *mv, CsrUint32 line, CsrCharString *file)
 #else
-void CsrSchedMessagePut(CsrSchedQid q, CsrUint16 mi, void *mv)
+void CsrSchedMessagePut(CsrSchedQid q, u16 mi, void *mv)
 #endif
 {
     CsrWifiFsmEvent* evt = (CsrWifiFsmEvent*)mv;
diff --git a/drivers/staging/csr/csr_wifi_serialize_primitive_types.c b/drivers/staging/csr/csr_wifi_serialize_primitive_types.c
index 0e5e20116e0..b81e51a8c4f 100644
--- a/drivers/staging/csr/csr_wifi_serialize_primitive_types.c
+++ b/drivers/staging/csr/csr_wifi_serialize_primitive_types.c
@@ -30,9 +30,9 @@ void CsrUint24Des(CsrUint32 *v, u8 *buffer, CsrSize *offset)
 
 
 /* Big endian :e.g WSC, TCLAS */
-void CsrUint16DesBigEndian(CsrUint16 *v, u8 *buffer, CsrSize *offset)
+void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset)
 {
-    CsrUint16 val;
+    u16 val;
 
     val = (buffer[(*offset)] << 8) | (buffer[(*offset) + 1]);
     *offset += 2;
@@ -79,7 +79,7 @@ void CsrUint24Ser(u8 *ptr, CsrSize *len, CsrUint32 v)
 
 
 /* Big endian :e.g WSC, TCLAS */
-void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, CsrUint16 v)
+void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, u16 v)
 {
     ptr[(*len)] = (u8)((v & 0xff00) >> 8);
     ptr[(*len) + 1] = (u8)((v & 0x00ff));
diff --git a/drivers/staging/csr/csr_wifi_sme_ap_lib.h b/drivers/staging/csr/csr_wifi_sme_ap_lib.h
index bb9e79f95ec..06e4130ef78 100644
--- a/drivers/staging/csr/csr_wifi_sme_ap_lib.h
+++ b/drivers/staging/csr/csr_wifi_sme_ap_lib.h
@@ -43,7 +43,7 @@ extern "C" {
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_SME_AP upstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiSmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiSmeApFreeUpstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  *  CsrWifiSmeApFreeDownstreamMessageContents
@@ -55,7 +55,7 @@ void CsrWifiSmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_SME_AP downstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiSmeApFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiSmeApFreeDownstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  * Enum to string functions
@@ -525,7 +525,7 @@ extern const CsrCharString *CsrWifiSmeApDownstreamPrimNames[CSR_WIFI_SME_AP_PRIM
     msg__->secIeLength = (secIeLength__); \
     msg__->secIe = (secIe__); \
     msg__->groupKeyId = (groupKeyId__); \
-    CsrMemCpy(msg__->seqNumber, (seqNumber__), sizeof(CsrUint16) * 8);
+    CsrMemCpy(msg__->seqNumber, (seqNumber__), sizeof(u16) * 8);
 
 #define CsrWifiSmeApStaNotifyIndSendTo(dst__, src__, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__, disassocReason__, deauthReason__, WpsRegistration__, secIeLength__, secIe__, groupKeyId__, seqNumber__) \
     { \
diff --git a/drivers/staging/csr/csr_wifi_sme_ap_prim.h b/drivers/staging/csr/csr_wifi_sme_ap_prim.h
index be275afa01b..363c10bdaf6 100644
--- a/drivers/staging/csr/csr_wifi_sme_ap_prim.h
+++ b/drivers/staging/csr/csr_wifi_sme_ap_prim.h
@@ -181,7 +181,7 @@ typedef u8 CsrWifiSmeApPhySupportMask;
     Set to 0 for the current release
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeApRsnCapabilities;
+typedef u16 CsrWifiSmeApRsnCapabilities;
 /*******************************************************************************
 
   NAME
@@ -191,7 +191,7 @@ typedef CsrUint16 CsrWifiSmeApRsnCapabilities;
     Mask type for use with the values defined by CsrWifiSmeApRsnCapabilities
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeApRsnCapabilitiesMask;
+typedef u16 CsrWifiSmeApRsnCapabilitiesMask;
 /*******************************************************************************
 
   NAME
@@ -202,7 +202,7 @@ typedef CsrUint16 CsrWifiSmeApRsnCapabilitiesMask;
     current release
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeApWapiCapabilities;
+typedef u16 CsrWifiSmeApWapiCapabilities;
 /*******************************************************************************
 
   NAME
@@ -212,7 +212,7 @@ typedef CsrUint16 CsrWifiSmeApWapiCapabilities;
     Mask type for use with the values defined by CsrWifiSmeApWapiCapabilities
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeApWapiCapabilitiesMask;
+typedef u16 CsrWifiSmeApWapiCapabilitiesMask;
 
 
 /*******************************************************************************
@@ -383,9 +383,9 @@ typedef struct
 typedef struct
 {
     CsrWifiSmeApPhySupportMask  phySupportedBitmap;
-    CsrUint16                   beaconInterval;
+    u16                   beaconInterval;
     u8                    dtimPeriod;
-    CsrUint16                   maxListenInterval;
+    u16                   maxListenInterval;
     u8                    supportedRatesCount;
     u8                    supportedRates[20];
     CsrWifiSmePreambleType      preamble;
@@ -550,7 +550,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent         common;
-    CsrUint16               interfaceTag;
+    u16               interfaceTag;
     u8                initialPresence;
     CsrWifiSmeApType        apType;
     CsrBool                 cloakSsid;
@@ -579,7 +579,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeApBeaconingStopReq;
 
 /*******************************************************************************
@@ -600,7 +600,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent         common;
-    CsrUint16               interfaceTag;
+    u16               interfaceTag;
     CsrWifiSmeWpsDpid       SelectedDevicePasswordId;
     CsrWifiSmeWpsConfigType SelectedconfigMethod;
 } CsrWifiSmeApWpsRegistrationStartedReq;
@@ -621,7 +621,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeApWpsRegistrationFinishedReq;
 
 /*******************************************************************************
@@ -643,7 +643,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent       common;
-    CsrUint16             interfaceTag;
+    u16             interfaceTag;
     CsrWifiSmeWmmAcParams wmmApParams[4];
     CsrWifiSmeWmmAcParams wmmApBcParams[4];
 } CsrWifiSmeApWmmParamUpdateReq;
@@ -671,7 +671,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrWifiSmeIEEE80211Reason deauthReason;
     CsrWifiSmeIEEE80211Reason disassocReason;
     CsrWifiMacAddress         peerMacaddress;
@@ -715,7 +715,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeApActiveBaGetReq;
 
 /*******************************************************************************
@@ -736,7 +736,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrWifiSmeIEEE80211Reason reason;
     CsrWifiSmeApBaSession     baSession;
 } CsrWifiSmeApBaDeleteReq;
@@ -761,9 +761,9 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
-    CsrUint16       secIeLength;
+    u16       secIeLength;
     u8       *secIe;
 } CsrWifiSmeApBeaconingStartCfm;
 
@@ -784,7 +784,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeApBeaconingStopCfm;
 
@@ -815,7 +815,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrWifiSmeMediaStatus     mediaStatus;
     CsrWifiMacAddress         peerMacAddress;
     CsrWifiMacAddress         peerDeviceAddress;
@@ -825,7 +825,7 @@ typedef struct
     u8                  secIeLength;
     u8                 *secIe;
     u8                  groupKeyId;
-    CsrUint16                 seqNumber[8];
+    u16                 seqNumber[8];
 } CsrWifiSmeApStaNotifyInd;
 
 /*******************************************************************************
@@ -846,7 +846,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent   common;
-    CsrUint16         interfaceTag;
+    u16         interfaceTag;
     CsrWifiMacAddress peerMacAddress;
 } CsrWifiSmeApStaConnectStartInd;
 
@@ -867,7 +867,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeApWpsRegistrationStartedCfm;
 
@@ -888,7 +888,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeApWpsRegistrationFinishedCfm;
 
@@ -909,7 +909,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeApWmmParamUpdateCfm;
 
@@ -931,7 +931,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent   common;
-    CsrUint16         interfaceTag;
+    u16         interfaceTag;
     CsrResult         status;
     CsrWifiMacAddress peerMacaddress;
 } CsrWifiSmeApStaDisconnectCfm;
@@ -976,7 +976,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent  common;
-    CsrUint16        interfaceTag;
+    u16        interfaceTag;
     CsrWifiSmeApType apType;
     CsrResult        status;
 } CsrWifiSmeApErrorInd;
@@ -1001,9 +1001,9 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent        common;
-    CsrUint16              interfaceTag;
+    u16              interfaceTag;
     CsrResult              status;
-    CsrUint16              activeBaCount;
+    u16              activeBaCount;
     CsrWifiSmeApBaSession *activeBaSessions;
 } CsrWifiSmeApActiveBaGetCfm;
 
@@ -1025,7 +1025,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent       common;
-    CsrUint16             interfaceTag;
+    u16             interfaceTag;
     CsrResult             status;
     CsrWifiSmeApBaSession baSession;
 } CsrWifiSmeApBaDeleteCfm;
diff --git a/drivers/staging/csr/csr_wifi_sme_converter_init.c b/drivers/staging/csr/csr_wifi_sme_converter_init.c
index 6897a77faf2..18373afcfdd 100644
--- a/drivers/staging/csr/csr_wifi_sme_converter_init.c
+++ b/drivers/staging/csr/csr_wifi_sme_converter_init.c
@@ -156,11 +156,11 @@ static CsrMsgConvMsgEntry csrwifisme_conv_lut[] = {
     { 0, NULL, NULL, NULL, NULL },
 };
 
-CsrMsgConvMsgEntry* CsrWifiSmeConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+CsrMsgConvMsgEntry* CsrWifiSmeConverterLookup(CsrMsgConvMsgEntry *ce, u16 msgType)
 {
     if (msgType & CSR_PRIM_UPSTREAM)
     {
-        CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT;
+        u16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT;
         if (idx < (CSR_WIFI_SME_PRIM_UPSTREAM_COUNT + CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT) &&
             csrwifisme_conv_lut[idx].msgType == msgType)
         {
diff --git a/drivers/staging/csr/csr_wifi_sme_free_downstream_contents.c b/drivers/staging/csr/csr_wifi_sme_free_downstream_contents.c
index 93e75e5ace1..826ef3a9b82 100644
--- a/drivers/staging/csr/csr_wifi_sme_free_downstream_contents.c
+++ b/drivers/staging/csr/csr_wifi_sme_free_downstream_contents.c
@@ -25,7 +25,7 @@
  *      eventClass: only the value CSR_WIFI_SME_PRIM will be handled
  *      message:    the message to free
  *----------------------------------------------------------------------------*/
-void CsrWifiSmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiSmeFreeDownstreamMessageContents(u16 eventClass, void *message)
 {
     if (eventClass != CSR_WIFI_SME_PRIM)
     {
@@ -132,7 +132,7 @@ void CsrWifiSmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message
         {
             CsrWifiSmeWifiFlightmodeReq *p = (CsrWifiSmeWifiFlightmodeReq *)message;
             {
-                CsrUint16 i1;
+                u16 i1;
                 for (i1 = 0; i1 < p->mibFilesCount; i1++)
                 {
                     CsrPmemFree(p->mibFiles[i1].data);
@@ -147,7 +147,7 @@ void CsrWifiSmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message
         {
             CsrWifiSmeWifiOnReq *p = (CsrWifiSmeWifiOnReq *)message;
             {
-                CsrUint16 i1;
+                u16 i1;
                 for (i1 = 0; i1 < p->mibFilesCount; i1++)
                 {
                     CsrPmemFree(p->mibFiles[i1].data);
diff --git a/drivers/staging/csr/csr_wifi_sme_free_upstream_contents.c b/drivers/staging/csr/csr_wifi_sme_free_upstream_contents.c
index c32bf6877bf..c34b57e960d 100644
--- a/drivers/staging/csr/csr_wifi_sme_free_upstream_contents.c
+++ b/drivers/staging/csr/csr_wifi_sme_free_upstream_contents.c
@@ -25,7 +25,7 @@
  *      eventClass: only the value CSR_WIFI_SME_PRIM will be handled
  *      message:    the message to free
  *----------------------------------------------------------------------------*/
-void CsrWifiSmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+void CsrWifiSmeFreeUpstreamMessageContents(u16 eventClass, void *message)
 {
     if (eventClass != CSR_WIFI_SME_PRIM)
     {
@@ -161,7 +161,7 @@ void CsrWifiSmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
             {
                 case CSR_WIFI_SME_P2P_ROLE_GO:
                 {
-                    CsrUint16 i4;
+                    u16 i4;
                     for (i4 = 0; i4 < p->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                     {
                         CsrPmemFree(p->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
@@ -184,7 +184,7 @@ void CsrWifiSmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
         {
             CsrWifiSmeScanResultsGetCfm *p = (CsrWifiSmeScanResultsGetCfm *)message;
             {
-                CsrUint16 i1;
+                u16 i1;
                 for (i1 = 0; i1 < p->scanResultsCount; i1++)
                 {
                     CsrPmemFree(p->scanResults[i1].informationElements);
@@ -193,7 +193,7 @@ void CsrWifiSmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
                     {
                         case CSR_WIFI_SME_P2P_ROLE_GO:
                         {
-                            CsrUint16 i4;
+                            u16 i4;
                             for (i4 = 0; i4 < p->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                             {
                                 CsrPmemFree(p->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
diff --git a/drivers/staging/csr/csr_wifi_sme_lib.h b/drivers/staging/csr/csr_wifi_sme_lib.h
index 63ac5dfcf28..1c05f03cf95 100644
--- a/drivers/staging/csr/csr_wifi_sme_lib.h
+++ b/drivers/staging/csr/csr_wifi_sme_lib.h
@@ -49,7 +49,7 @@ extern "C" {
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_SME upstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiSmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiSmeFreeUpstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  *  CsrWifiSmeFreeDownstreamMessageContents
@@ -61,7 +61,7 @@ void CsrWifiSmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
  *  PARAMETERS
  *      Deallocates the resources in a CSR_WIFI_SME downstream message
  *----------------------------------------------------------------------------*/
-void CsrWifiSmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+void CsrWifiSmeFreeDownstreamMessageContents(u16 eventClass, void *message);
 
 /*----------------------------------------------------------------------------*
  * Enum to string functions
diff --git a/drivers/staging/csr/csr_wifi_sme_prim.h b/drivers/staging/csr/csr_wifi_sme_prim.h
index 700f268ca76..731f4bf0819 100644
--- a/drivers/staging/csr/csr_wifi_sme_prim.h
+++ b/drivers/staging/csr/csr_wifi_sme_prim.h
@@ -161,7 +161,7 @@ typedef u8 CsrWifiSmeAmpStatus;
                    - For future use.
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeAuthMode;
+typedef u16 CsrWifiSmeAuthMode;
 #define CSR_WIFI_SME_AUTH_MODE_80211_OPEN      ((CsrWifiSmeAuthMode) 0x0001)
 #define CSR_WIFI_SME_AUTH_MODE_80211_SHARED    ((CsrWifiSmeAuthMode) 0x0002)
 #define CSR_WIFI_SME_AUTH_MODE_8021X_WPA       ((CsrWifiSmeAuthMode) 0x0004)
@@ -368,7 +368,7 @@ typedef u8 CsrWifiSmeD3AutoScanMode;
                    - Selects SMS4 for broadcast messages
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeEncryption;
+typedef u16 CsrWifiSmeEncryption;
 #define CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE              ((CsrWifiSmeEncryption) 0x0000)
 #define CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP40    ((CsrWifiSmeEncryption) 0x0001)
 #define CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP104   ((CsrWifiSmeEncryption) 0x0002)
@@ -525,7 +525,7 @@ typedef u8 CsrWifiSmeHostPowerMode;
                    - See IEEE 802.11 Standard
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeIEEE80211Reason;
+typedef u16 CsrWifiSmeIEEE80211Reason;
 #define CSR_WIFI_SME_IEEE80211_REASON_SUCCESS                                   ((CsrWifiSmeIEEE80211Reason) 0x0000)
 #define CSR_WIFI_SME_IEEE80211_REASON_UNSPECIFIED_REASON                        ((CsrWifiSmeIEEE80211Reason) 0x0001)
 #define CSR_WIFI_SME_IEEE80211_REASON_AUTHENTICATION_NOT_VALID                  ((CsrWifiSmeIEEE80211Reason) 0x0002)
@@ -712,7 +712,7 @@ typedef CsrUint16 CsrWifiSmeIEEE80211Reason;
                    - See IEEE 802.11 Standard
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeIEEE80211Result;
+typedef u16 CsrWifiSmeIEEE80211Result;
 #define CSR_WIFI_SME_IEEE80211_RESULT_SUCCESS                                          ((CsrWifiSmeIEEE80211Result) 0x0000)
 #define CSR_WIFI_SME_IEEE80211_RESULT_UNSPECIFIED_FAILURE                              ((CsrWifiSmeIEEE80211Result) 0x0001)
 #define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_CAPABILITIES_MISMATCH                    ((CsrWifiSmeIEEE80211Result) 0x000a)
@@ -1534,7 +1534,7 @@ typedef u8 CsrWifiSmeWmmQosInfo;
                    - Physical Display : Attached to the device
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeWpsConfigType;
+typedef u16 CsrWifiSmeWpsConfigType;
 #define CSR_WIFI_WPS_CONFIG_LABEL              ((CsrWifiSmeWpsConfigType) 0x0004)
 #define CSR_WIFI_WPS_CONFIG_DISPLAY            ((CsrWifiSmeWpsConfigType) 0x0008)
 #define CSR_WIFI_WPS_CONFIG_EXT_NFC            ((CsrWifiSmeWpsConfigType) 0x0010)
@@ -1806,7 +1806,7 @@ typedef u8 CsrWifiSmeWpsDeviceSubCategory;
                                       negotiation procedure
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeWpsDpid;
+typedef u16 CsrWifiSmeWpsDpid;
 #define CSR_WIFI_SME_WPS_DPID_PIN         ((CsrWifiSmeWpsDpid) 0x0000)
 #define CSR_WIFI_SME_WPS_DPID_USER        ((CsrWifiSmeWpsDpid) 0x0001)
 #define CSR_WIFI_SME_WPS_DPID_MACHINE     ((CsrWifiSmeWpsDpid) 0x0002)
@@ -1842,7 +1842,7 @@ typedef u8 CsrWifiSmeWpsRegistration;
     Mask type for use with the values defined by CsrWifiSmeAuthMode
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeAuthModeMask;
+typedef u16 CsrWifiSmeAuthModeMask;
 /*******************************************************************************
 
   NAME
@@ -1852,7 +1852,7 @@ typedef CsrUint16 CsrWifiSmeAuthModeMask;
     Mask type for use with the values defined by CsrWifiSmeEncryption
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeEncryptionMask;
+typedef u16 CsrWifiSmeEncryptionMask;
 /*******************************************************************************
 
   NAME
@@ -1922,7 +1922,7 @@ typedef u8 CsrWifiSmeWmmQosInfoMask;
     Mask type for use with the values defined by CsrWifiSmeWpsConfigType
 
 *******************************************************************************/
-typedef CsrUint16 CsrWifiSmeWpsConfigTypeMask;
+typedef u16 CsrWifiSmeWpsConfigTypeMask;
 
 
 /*******************************************************************************
@@ -1944,10 +1944,10 @@ typedef CsrUint16 CsrWifiSmeWpsConfigTypeMask;
 *******************************************************************************/
 typedef struct
 {
-    CsrUint16 atimWindowTu;
-    CsrUint16 beaconPeriodTu;
-    CsrUint16 joinOnlyAttempts;
-    CsrUint16 joinAttemptIntervalMs;
+    u16 atimWindowTu;
+    u16 beaconPeriodTu;
+    u16 joinOnlyAttempts;
+    u16 joinAttemptIntervalMs;
 } CsrWifiSmeAdHocConfig;
 
 /*******************************************************************************
@@ -1966,8 +1966,8 @@ typedef struct
 typedef struct
 {
     u8  listenChannel;
-    CsrUint16 availabilityDuration;
-    CsrUint16 avalabilityPeriod;
+    u16 availabilityDuration;
+    u16 avalabilityPeriod;
 } CsrWifiSmeAvailabilityConfig;
 
 /*******************************************************************************
@@ -2039,18 +2039,18 @@ typedef struct
 {
     CsrBool   coexEnableSchemeManagement;
     CsrBool   coexPeriodicWakeHost;
-    CsrUint16 coexTrafficBurstyLatencyMs;
-    CsrUint16 coexTrafficContinuousLatencyMs;
-    CsrUint16 coexObexBlackoutDurationMs;
-    CsrUint16 coexObexBlackoutPeriodMs;
-    CsrUint16 coexA2dpBrBlackoutDurationMs;
-    CsrUint16 coexA2dpBrBlackoutPeriodMs;
-    CsrUint16 coexA2dpEdrBlackoutDurationMs;
-    CsrUint16 coexA2dpEdrBlackoutPeriodMs;
-    CsrUint16 coexPagingBlackoutDurationMs;
-    CsrUint16 coexPagingBlackoutPeriodMs;
-    CsrUint16 coexInquiryBlackoutDurationMs;
-    CsrUint16 coexInquiryBlackoutPeriodMs;
+    u16 coexTrafficBurstyLatencyMs;
+    u16 coexTrafficContinuousLatencyMs;
+    u16 coexObexBlackoutDurationMs;
+    u16 coexObexBlackoutPeriodMs;
+    u16 coexA2dpBrBlackoutDurationMs;
+    u16 coexA2dpBrBlackoutPeriodMs;
+    u16 coexA2dpEdrBlackoutDurationMs;
+    u16 coexA2dpEdrBlackoutPeriodMs;
+    u16 coexPagingBlackoutDurationMs;
+    u16 coexPagingBlackoutPeriodMs;
+    u16 coexInquiryBlackoutDurationMs;
+    u16 coexInquiryBlackoutPeriodMs;
 } CsrWifiSmeCoexConfig;
 
 /*******************************************************************************
@@ -2167,7 +2167,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint16 length;
+    u16 length;
     u8 *data;
 } CsrWifiSmeDataBlock;
 
@@ -2233,9 +2233,9 @@ typedef struct
 {
     CsrBool   unifiFixMaxTxDataRate;
     u8  unifiFixTxDataRate;
-    CsrUint16 dot11RtsThreshold;
-    CsrUint16 dot11FragmentationThreshold;
-    CsrUint16 dot11CurrentTxPowerLevel;
+    u16 dot11RtsThreshold;
+    u16 dot11FragmentationThreshold;
+    u16 dot11CurrentTxPowerLevel;
 } CsrWifiSmeMibConfig;
 
 /*******************************************************************************
@@ -2255,8 +2255,8 @@ typedef struct
 typedef struct
 {
     u8  listenChannel;
-    CsrUint16 availabilityDuration;
-    CsrUint16 avalabilityPeriod;
+    u16 availabilityDuration;
+    u16 avalabilityPeriod;
 } CsrWifiSmeP2pProfileIdentity;
 
 /*******************************************************************************
@@ -2402,12 +2402,12 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint16 intervalSeconds;
-    CsrUint16 validitySeconds;
-    CsrUint16 minActiveChannelTimeTu;
-    CsrUint16 maxActiveChannelTimeTu;
-    CsrUint16 minPassiveChannelTimeTu;
-    CsrUint16 maxPassiveChannelTimeTu;
+    u16 intervalSeconds;
+    u16 validitySeconds;
+    u16 minActiveChannelTimeTu;
+    u16 maxActiveChannelTimeTu;
+    u16 minPassiveChannelTimeTu;
+    u16 maxPassiveChannelTimeTu;
 } CsrWifiSmeScanConfigData;
 
 /*******************************************************************************
@@ -2488,7 +2488,7 @@ typedef struct
     u8  cwMin;
     u8  cwMax;
     u8  aifs;
-    CsrUint16 txopLimit;
+    u16 txopLimit;
     CsrBool   admissionControlMandatory;
 } CsrWifiSmeWmmAcParams;
 
@@ -2542,9 +2542,9 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint16 version;
-    CsrUint16 configMethods;
-    CsrUint16 devicePassworId;
+    u16 version;
+    u16 configMethods;
+    u16 devicePassworId;
 } CsrWifiSmeWpsInfo;
 
 /*******************************************************************************
@@ -2598,10 +2598,10 @@ typedef struct
 {
     CsrBool                  hasTrafficData;
     CsrWifiSmeTrafficType    currentTrafficType;
-    CsrUint16                currentPeriodMs;
+    u16                currentPeriodMs;
     CsrWifiSmePowerSaveLevel currentPowerSave;
-    CsrUint16                currentCoexPeriodMs;
-    CsrUint16                currentCoexLatencyMs;
+    u16                currentCoexPeriodMs;
+    u16                currentCoexLatencyMs;
     CsrBool                  hasBtDevice;
     CsrUint32                currentBlackoutDurationUs;
     CsrUint32                currentBlackoutPeriodUs;
@@ -2674,7 +2674,7 @@ typedef struct
     CsrWifiSme80211PrivacyMode privacyMode;
     CsrWifiSmeAuthModeMask     authModeMask;
     CsrWifiSmeEncryptionMask   encryptionModeMask;
-    CsrUint16                  mlmeAssociateReqInformationElementsLength;
+    u16                  mlmeAssociateReqInformationElementsLength;
     u8                  *mlmeAssociateReqInformationElements;
     CsrWifiSmeWmmQosInfoMask   wmmQosInfo;
     CsrBool                    adhocJoinOnly;
@@ -2749,31 +2749,31 @@ typedef struct
     CsrWifiMacAddress          bssid;
     CsrWifiSme80211NetworkType networkType80211;
     u8                   channelNumber;
-    CsrUint16                  channelFrequency;
+    u16                  channelFrequency;
     CsrWifiSmeAuthMode         authMode;
     CsrWifiSmeEncryption       pairwiseCipher;
     CsrWifiSmeEncryption       groupCipher;
     CsrWifiSmeRadioIF          ifIndex;
-    CsrUint16                  atimWindowTu;
-    CsrUint16                  beaconPeriodTu;
+    u16                  atimWindowTu;
+    u16                  beaconPeriodTu;
     CsrBool                    reassociation;
-    CsrUint16                  beaconFrameLength;
+    u16                  beaconFrameLength;
     u8                  *beaconFrame;
-    CsrUint16                  associationReqFrameLength;
+    u16                  associationReqFrameLength;
     u8                  *associationReqFrame;
-    CsrUint16                  associationRspFrameLength;
+    u16                  associationRspFrameLength;
     u8                  *associationRspFrame;
-    CsrUint16                  assocScanInfoElementsLength;
+    u16                  assocScanInfoElementsLength;
     u8                  *assocScanInfoElements;
-    CsrUint16                  assocReqCapabilities;
-    CsrUint16                  assocReqListenIntervalTu;
+    u16                  assocReqCapabilities;
+    u16                  assocReqListenIntervalTu;
     CsrWifiMacAddress          assocReqApAddress;
-    CsrUint16                  assocReqInfoElementsLength;
+    u16                  assocReqInfoElementsLength;
     u8                  *assocReqInfoElements;
     CsrWifiSmeIEEE80211Result  assocRspResult;
-    CsrUint16                  assocRspCapabilityInfo;
-    CsrUint16                  assocRspAssociationId;
-    CsrUint16                  assocRspInfoElementsLength;
+    u16                  assocRspCapabilityInfo;
+    u16                  assocRspAssociationId;
+    u16                  assocRspInfoElementsLength;
     u8                  *assocRspInfoElements;
 } CsrWifiSmeConnectionInfo;
 
@@ -2890,7 +2890,7 @@ typedef struct
 typedef struct
 {
     CsrWifiSmeHostPowerMode powerMode;
-    CsrUint16               applicationDataPeriodMs;
+    u16               applicationDataPeriodMs;
 } CsrWifiSmeHostConfig;
 
 /*******************************************************************************
@@ -2926,7 +2926,7 @@ typedef struct
     CsrWifiSmeKeyType keyType;
     u8          keyIndex;
     CsrBool           wepTxKey;
-    CsrUint16         keyRsc[8];
+    u16         keyRsc[8];
     CsrBool           authenticator;
     CsrWifiMacAddress address;
     u8          keyLength;
@@ -3000,7 +3000,7 @@ typedef struct
 typedef struct
 {
     CsrWifiSmePowerSaveLevel powerSaveLevel;
-    CsrUint16                listenIntervalTu;
+    u16                listenIntervalTu;
     CsrBool                  rxDtims;
     CsrWifiSmeD3AutoScanMode d3AutoScanMode;
     u8                 clientTrafficWindow;
@@ -3042,7 +3042,7 @@ typedef struct
     CsrBool                   disableSmoothRoaming;
     CsrBool                   disableRoamScans;
     u8                  reconnectLimit;
-    CsrUint16                 reconnectLimitIntervalMs;
+    u16                 reconnectLimitIntervalMs;
     CsrWifiSmeScanConfigData  roamScanCfg[3];
 } CsrWifiSmeRoamingConfig;
 
@@ -3086,14 +3086,14 @@ typedef struct
 {
     CsrWifiSmeScanConfigData scanCfg[4];
     CsrBool                  disableAutonomousScans;
-    CsrUint16                maxResults;
+    u16                maxResults;
     s8                  highRssiThreshold;
     s8                  lowRssiThreshold;
     s8                  deltaRssiThreshold;
     s8                  highSnrThreshold;
     s8                  lowSnrThreshold;
     s8                  deltaSnrThreshold;
-    CsrUint16                passiveChannelListCount;
+    u16                passiveChannelListCount;
     u8                *passiveChannelList;
 } CsrWifiSmeScanConfig;
 
@@ -3144,15 +3144,15 @@ typedef struct
     CsrInt16                 rssi;
     CsrInt16                 snr;
     CsrWifiSmeRadioIF        ifIndex;
-    CsrUint16                beaconPeriodTu;
+    u16                beaconPeriodTu;
     CsrWifiSmeTsfTime        timeStamp;
     CsrWifiSmeTsfTime        localTime;
-    CsrUint16                channelFrequency;
-    CsrUint16                capabilityInformation;
+    u16                channelFrequency;
+    u16                capabilityInformation;
     u8                 channelNumber;
     CsrWifiSmeBasicUsability usability;
     CsrWifiSmeBssType        bssType;
-    CsrUint16                informationElementsLength;
+    u16                informationElementsLength;
     u8                *informationElements;
     CsrWifiSmeP2pRole        p2pDeviceRole;
     union {
@@ -3562,7 +3562,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent      common;
-    CsrUint16            interfaceTag;
+    u16            interfaceTag;
     CsrWifiSmeListAction action;
     u8             setAddressCount;
     CsrWifiMacAddress   *setAddresses;
@@ -3606,7 +3606,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       calibrationDataLength;
+    u16       calibrationDataLength;
     u8       *calibrationData;
 } CsrWifiSmeCalibrationDataSetReq;
 
@@ -3627,7 +3627,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeCcxConfigGetReq;
 
 /*******************************************************************************
@@ -3648,7 +3648,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent     common;
-    CsrUint16           interfaceTag;
+    u16           interfaceTag;
     CsrWifiSmeCcxConfig ccxConfig;
 } CsrWifiSmeCcxConfigSetReq;
 
@@ -3758,7 +3758,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent            common;
-    CsrUint16                  interfaceTag;
+    u16                  interfaceTag;
     CsrWifiSmeConnectionConfig connectionConfig;
 } CsrWifiSmeConnectReq;
 
@@ -3778,7 +3778,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeConnectionConfigGetReq;
 
 /*******************************************************************************
@@ -3797,7 +3797,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeConnectionInfoGetReq;
 
 /*******************************************************************************
@@ -3816,7 +3816,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeConnectionStatsGetReq;
 
 /*******************************************************************************
@@ -3853,7 +3853,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeDisconnectReq;
 
 /*******************************************************************************
@@ -3894,7 +3894,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeHostConfigGetReq;
 
 /*******************************************************************************
@@ -3916,7 +3916,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent      common;
-    CsrUint16            interfaceTag;
+    u16            interfaceTag;
     CsrWifiSmeHostConfig hostConfig;
 } CsrWifiSmeHostConfigSetReq;
 
@@ -3943,7 +3943,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent      common;
-    CsrUint16            interfaceTag;
+    u16            interfaceTag;
     CsrWifiSmeListAction action;
     CsrWifiSmeKey        key;
 } CsrWifiSmeKeyReq;
@@ -3964,7 +3964,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeLinkQualityGetReq;
 
 /*******************************************************************************
@@ -4023,7 +4023,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       mibAttributeLength;
+    u16       mibAttributeLength;
     u8       *mibAttribute;
 } CsrWifiSmeMibGetNextReq;
 
@@ -4046,7 +4046,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       mibAttributeLength;
+    u16       mibAttributeLength;
     u8       *mibAttribute;
 } CsrWifiSmeMibGetReq;
 
@@ -4077,7 +4077,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       mibAttributeLength;
+    u16       mibAttributeLength;
     u8       *mibAttribute;
 } CsrWifiSmeMibSetReq;
 
@@ -4107,7 +4107,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent      common;
-    CsrUint16            interfaceTag;
+    u16            interfaceTag;
     CsrWifiSmeListAction action;
     u8             setAddressesCount;
     CsrWifiMacAddress   *setAddresses;
@@ -4157,8 +4157,8 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent            common;
-    CsrUint16                  interfaceTag;
-    CsrUint16                  filterLength;
+    u16                  interfaceTag;
+    u16                  filterLength;
     u8                  *filter;
     CsrWifiSmePacketFilterMode mode;
     CsrWifiIp4Address          arpFilterAddress;
@@ -4209,7 +4209,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent      common;
-    CsrUint16            interfaceTag;
+    u16            interfaceTag;
     CsrWifiSmeListAction action;
     u8             setPmkidsCount;
     CsrWifiSmePmkid     *setPmkids;
@@ -4284,7 +4284,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeRoamingConfigGetReq;
 
 /*******************************************************************************
@@ -4304,7 +4304,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent         common;
-    CsrUint16               interfaceTag;
+    u16               interfaceTag;
     CsrWifiSmeRoamingConfig roamingConfig;
 } CsrWifiSmeRoamingConfigSetReq;
 
@@ -4404,9 +4404,9 @@ typedef struct
     CsrBool            forceScan;
     CsrWifiSmeBssType  bssType;
     CsrWifiSmeScanType scanType;
-    CsrUint16          channelListCount;
+    u16          channelListCount;
     u8          *channelList;
-    CsrUint16          probeIeLength;
+    u16          probeIeLength;
     u8          *probeIe;
 } CsrWifiSmeScanFullReq;
 
@@ -4471,7 +4471,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
 } CsrWifiSmeSmeStaConfigGetReq;
 
 /*******************************************************************************
@@ -4491,7 +4491,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent     common;
-    CsrUint16           interfaceTag;
+    u16           interfaceTag;
     CsrWifiSmeStaConfig smeConfig;
 } CsrWifiSmeSmeStaConfigSetReq;
 
@@ -4558,14 +4558,14 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent         common;
-    CsrUint16               interfaceTag;
+    u16               interfaceTag;
     CsrWifiSmeListAction    action;
     CsrUint32               transactionId;
     CsrBool                 strict;
     CsrWifiSmeTspecCtrlMask ctrlMask;
-    CsrUint16               tspecLength;
+    u16               tspecLength;
     u8               *tspec;
-    CsrUint16               tclasLength;
+    u16               tclasLength;
     u8               *tclas;
 } CsrWifiSmeTspecReq;
 
@@ -4631,7 +4631,7 @@ typedef struct
 {
     CsrWifiFsmEvent      common;
     CsrWifiMacAddress    address;
-    CsrUint16            mibFilesCount;
+    u16            mibFilesCount;
     CsrWifiSmeDataBlock *mibFiles;
 } CsrWifiSmeWifiFlightmodeReq;
 
@@ -4691,7 +4691,7 @@ typedef struct
 {
     CsrWifiFsmEvent      common;
     CsrWifiMacAddress    address;
-    CsrUint16            mibFilesCount;
+    u16            mibFilesCount;
     CsrWifiSmeDataBlock *mibFiles;
 } CsrWifiSmeWifiOnReq;
 
@@ -4922,7 +4922,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrResult                 status;
     CsrWifiSmeConnectionInfo  connectionInfo;
     CsrWifiSmeIEEE80211Reason deauthReason;
@@ -4947,7 +4947,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent   common;
-    CsrUint16         interfaceTag;
+    u16         interfaceTag;
     CsrWifiMacAddress address;
     CsrWifiSsid       ssid;
 } CsrWifiSmeAssociationStartInd;
@@ -4977,7 +4977,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent      common;
-    CsrUint16            interfaceTag;
+    u16            interfaceTag;
     CsrResult            status;
     CsrWifiSmeListAction action;
     u8             getAddressCount;
@@ -5005,7 +5005,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrResult       status;
-    CsrUint16       calibrationDataLength;
+    u16       calibrationDataLength;
     u8       *calibrationData;
 } CsrWifiSmeCalibrationDataGetCfm;
 
@@ -5046,7 +5046,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent     common;
-    CsrUint16           interfaceTag;
+    u16           interfaceTag;
     CsrResult           status;
     CsrWifiSmeCcxConfig ccxConfig;
 } CsrWifiSmeCcxConfigGetCfm;
@@ -5068,7 +5068,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeCcxConfigSetCfm;
 
@@ -5154,7 +5154,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeConnectCfm;
 
@@ -5176,7 +5176,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent            common;
-    CsrUint16                  interfaceTag;
+    u16                  interfaceTag;
     CsrResult                  status;
     CsrWifiSmeConnectionConfig connectionConfig;
 } CsrWifiSmeConnectionConfigGetCfm;
@@ -5199,7 +5199,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent          common;
-    CsrUint16                interfaceTag;
+    u16                interfaceTag;
     CsrResult                status;
     CsrWifiSmeConnectionInfo connectionInfo;
 } CsrWifiSmeConnectionInfoGetCfm;
@@ -5228,7 +5228,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent       common;
-    CsrUint16             interfaceTag;
+    u16             interfaceTag;
     CsrWifiSmeLinkQuality linkQuality;
 } CsrWifiSmeConnectionQualityInd;
 
@@ -5250,7 +5250,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrResult                 status;
     CsrWifiSmeConnectionStats connectionStats;
 } CsrWifiSmeConnectionStatsGetCfm;
@@ -5296,7 +5296,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeDisconnectCfm;
 
@@ -5338,7 +5338,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent      common;
-    CsrUint16            interfaceTag;
+    u16            interfaceTag;
     CsrResult            status;
     CsrWifiSmeHostConfig hostConfig;
 } CsrWifiSmeHostConfigGetCfm;
@@ -5360,7 +5360,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeHostConfigSetCfm;
 
@@ -5407,7 +5407,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent      common;
-    CsrUint16            interfaceTag;
+    u16            interfaceTag;
     CsrResult            status;
     CsrWifiSmeListAction action;
     CsrWifiSmeKeyType    keyType;
@@ -5432,7 +5432,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent       common;
-    CsrUint16             interfaceTag;
+    u16             interfaceTag;
     CsrResult             status;
     CsrWifiSmeLinkQuality linkQuality;
 } CsrWifiSmeLinkQualityGetCfm;
@@ -5467,7 +5467,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrWifiSmeMediaStatus     mediaStatus;
     CsrWifiSmeConnectionInfo  connectionInfo;
     CsrWifiSmeIEEE80211Reason disassocReason;
@@ -5534,7 +5534,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrResult       status;
-    CsrUint16       mibAttributeLength;
+    u16       mibAttributeLength;
     u8       *mibAttribute;
 } CsrWifiSmeMibGetCfm;
 
@@ -5561,7 +5561,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrResult       status;
-    CsrUint16       mibAttributeLength;
+    u16       mibAttributeLength;
     u8       *mibAttribute;
 } CsrWifiSmeMibGetNextCfm;
 
@@ -5607,9 +5607,9 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent   common;
-    CsrUint16         interfaceTag;
+    u16         interfaceTag;
     CsrBool           secondFailure;
-    CsrUint16         count;
+    u16         count;
     CsrWifiMacAddress address;
     CsrWifiSmeKeyType keyType;
 } CsrWifiSmeMicFailureInd;
@@ -5638,7 +5638,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent      common;
-    CsrUint16            interfaceTag;
+    u16            interfaceTag;
     CsrResult            status;
     CsrWifiSmeListAction action;
     u8             getAddressesCount;
@@ -5662,7 +5662,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmePacketFilterSetCfm;
 
@@ -5708,7 +5708,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     u8                  pmkidCandidatesCount;
     CsrWifiSmePmkidCandidate *pmkidCandidates;
 } CsrWifiSmePmkidCandidateListInd;
@@ -5737,7 +5737,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent      common;
-    CsrUint16            interfaceTag;
+    u16            interfaceTag;
     CsrResult            status;
     CsrWifiSmeListAction action;
     u8             getPmkidsCount;
@@ -5827,7 +5827,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeRoamCompleteInd;
 
@@ -5867,7 +5867,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrWifiSmeRoamReason      roamReason;
     CsrWifiSmeIEEE80211Reason reason80211;
 } CsrWifiSmeRoamStartInd;
@@ -5890,7 +5890,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent         common;
-    CsrUint16               interfaceTag;
+    u16               interfaceTag;
     CsrResult               status;
     CsrWifiSmeRoamingConfig roamingConfig;
 } CsrWifiSmeRoamingConfigGetCfm;
@@ -5912,7 +5912,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeRoamingConfigSetCfm;
 
@@ -6036,7 +6036,7 @@ typedef struct
 {
     CsrWifiFsmEvent       common;
     CsrResult             status;
-    CsrUint16             scanResultsCount;
+    u16             scanResultsCount;
     CsrWifiSmeScanResult *scanResults;
 } CsrWifiSmeScanResultsGetCfm;
 
@@ -6058,7 +6058,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent     common;
-    CsrUint16           interfaceTag;
+    u16           interfaceTag;
     CsrResult           status;
     CsrWifiSmeStaConfig smeConfig;
 } CsrWifiSmeSmeStaConfigGetCfm;
@@ -6080,7 +6080,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint16       interfaceTag;
+    u16       interfaceTag;
     CsrResult       status;
 } CsrWifiSmeSmeStaConfigSetCfm;
 
@@ -6128,10 +6128,10 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrUint32                 transactionId;
     CsrWifiSmeTspecResultCode tspecResultCode;
-    CsrUint16                 tspecLength;
+    u16                 tspecLength;
     u8                 *tspec;
 } CsrWifiSmeTspecInd;
 
@@ -6158,11 +6158,11 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent           common;
-    CsrUint16                 interfaceTag;
+    u16                 interfaceTag;
     CsrResult                 status;
     CsrUint32                 transactionId;
     CsrWifiSmeTspecResultCode tspecResultCode;
-    CsrUint16                 tspecLength;
+    u16                 tspecLength;
     u8                 *tspec;
 } CsrWifiSmeTspecCfm;
 
@@ -6399,7 +6399,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrResult       status;
-    CsrUint16       numInterfaces;
+    u16       numInterfaces;
     u8        capBitmap[2];
 } CsrWifiSmeInterfaceCapabilityGetCfm;
 
@@ -6487,7 +6487,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent     common;
-    CsrUint16           interfaceTag;
+    u16           interfaceTag;
     CsrWifiSmeAmpStatus ampStatus;
 } CsrWifiSmeAmpStatusChangeInd;
 
diff --git a/drivers/staging/csr/csr_wifi_sme_serialize.c b/drivers/staging/csr/csr_wifi_sme_serialize.c
index f35f8368525..0e3096e969f 100644
--- a/drivers/staging/csr/csr_wifi_sme_serialize.c
+++ b/drivers/staging/csr/csr_wifi_sme_serialize.c
@@ -29,10 +29,10 @@ CsrSize CsrWifiSmeAdhocConfigSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
-    bufferSize += 2; /* CsrUint16 primitive->adHocConfig.atimWindowTu */
-    bufferSize += 2; /* CsrUint16 primitive->adHocConfig.beaconPeriodTu */
-    bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinOnlyAttempts */
-    bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinAttemptIntervalMs */
+    bufferSize += 2; /* u16 primitive->adHocConfig.atimWindowTu */
+    bufferSize += 2; /* u16 primitive->adHocConfig.beaconPeriodTu */
+    bufferSize += 2; /* u16 primitive->adHocConfig.joinOnlyAttempts */
+    bufferSize += 2; /* u16 primitive->adHocConfig.joinAttemptIntervalMs */
     return bufferSize;
 }
 
@@ -42,10 +42,10 @@ u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeAdhocConfigSetReq *primitive = (CsrWifiSmeAdhocConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.atimWindowTu);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.beaconPeriodTu);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinOnlyAttempts);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinAttemptIntervalMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.atimWindowTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.beaconPeriodTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.joinOnlyAttempts);
+    CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.joinAttemptIntervalMs);
     return(ptr);
 }
 
@@ -57,10 +57,10 @@ void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.atimWindowTu, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.beaconPeriodTu, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinOnlyAttempts, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinAttemptIntervalMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->adHocConfig.atimWindowTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->adHocConfig.beaconPeriodTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->adHocConfig.joinOnlyAttempts, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->adHocConfig.joinAttemptIntervalMs, buffer, &offset);
 
     return primitive;
 }
@@ -72,11 +72,11 @@ CsrSize CsrWifiSmeBlacklistReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
     bufferSize += 1; /* u8 primitive->setAddressCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setAddressCount; i1++)
         {
             bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
@@ -91,14 +91,14 @@ u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint8Ser(ptr, len, (u8) primitive->setAddressCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setAddressCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((u16) (6)));
         }
     }
     return(ptr);
@@ -112,7 +112,7 @@ void* CsrWifiSmeBlacklistReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->setAddressCount, buffer, &offset);
     primitive->setAddresses = NULL;
@@ -121,10 +121,10 @@ void* CsrWifiSmeBlacklistReqDes(u8 *buffer, CsrSize length)
         primitive->setAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->setAddressCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setAddressCount; i1++)
         {
-            CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((u16) (6)));
         }
     }
 
@@ -146,7 +146,7 @@ CsrSize CsrWifiSmeCalibrationDataSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
-    bufferSize += 2;                                /* CsrUint16 primitive->calibrationDataLength */
+    bufferSize += 2;                                /* u16 primitive->calibrationDataLength */
     bufferSize += primitive->calibrationDataLength; /* u8 primitive->calibrationData */
     return bufferSize;
 }
@@ -157,10 +157,10 @@ u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->calibrationDataLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->calibrationDataLength);
     if (primitive->calibrationDataLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->calibrationData, ((CsrUint16) (primitive->calibrationDataLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->calibrationData, ((u16) (primitive->calibrationDataLength)));
     }
     return(ptr);
 }
@@ -173,11 +173,11 @@ void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->calibrationDataLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->calibrationDataLength, buffer, &offset);
     if (primitive->calibrationDataLength)
     {
         primitive->calibrationData = (u8 *)CsrPmemAlloc(primitive->calibrationDataLength);
-        CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((CsrUint16) (primitive->calibrationDataLength)));
+        CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((u16) (primitive->calibrationDataLength)));
     }
     else
     {
@@ -201,7 +201,7 @@ CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* u8 primitive->ccxConfig.keepAliveTimeMs */
     bufferSize += 1; /* CsrBool primitive->ccxConfig.apRoamingEnabled */
     bufferSize += 1; /* u8 primitive->ccxConfig.measurementsMask */
@@ -215,7 +215,7 @@ u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeCcxConfigSetReq *primitive = (CsrWifiSmeCcxConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.keepAliveTimeMs);
     CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.apRoamingEnabled);
     CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.measurementsMask);
@@ -231,7 +231,7 @@ void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
@@ -248,18 +248,18 @@ CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 29) */
     bufferSize += 1; /* CsrBool primitive->coexConfig.coexEnableSchemeManagement */
     bufferSize += 1; /* CsrBool primitive->coexConfig.coexPeriodicWakeHost */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficBurstyLatencyMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficContinuousLatencyMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutDurationMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutPeriodMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutDurationMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutPeriodMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutDurationMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutDurationMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutPeriodMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutDurationMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexTrafficBurstyLatencyMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexTrafficContinuousLatencyMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexObexBlackoutDurationMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexObexBlackoutPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpBrBlackoutDurationMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpBrBlackoutPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpEdrBlackoutDurationMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexPagingBlackoutDurationMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexPagingBlackoutPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexInquiryBlackoutDurationMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexInquiryBlackoutPeriodMs */
     return bufferSize;
 }
 
@@ -271,18 +271,18 @@ u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexEnableSchemeManagement);
     CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexPeriodicWakeHost);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutDurationMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutPeriodMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutDurationMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutPeriodMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutDurationMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutDurationMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutPeriodMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutDurationMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexObexBlackoutDurationMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexObexBlackoutPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpBrBlackoutDurationMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpBrBlackoutPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpEdrBlackoutDurationMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexPagingBlackoutDurationMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexPagingBlackoutPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexInquiryBlackoutDurationMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexInquiryBlackoutPeriodMs);
     return(ptr);
 }
 
@@ -296,18 +296,18 @@ void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->coexConfig.coexPeriodicWakeHost, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutPeriodMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutDurationMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutPeriodMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutDurationMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutDurationMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutPeriodMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutDurationMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexObexBlackoutPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpBrBlackoutDurationMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpBrBlackoutPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpEdrBlackoutDurationMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexPagingBlackoutDurationMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexPagingBlackoutPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexInquiryBlackoutDurationMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexInquiryBlackoutPeriodMs, buffer, &offset);
 
     return primitive;
 }
@@ -319,7 +319,7 @@ CsrSize CsrWifiSmeConnectReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 57) */
-    bufferSize += 2;                                                                     /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                                                                     /* u16 primitive->interfaceTag */
     bufferSize += 32;                                                                    /* u8 primitive->connectionConfig.ssid.ssid[32] */
     bufferSize += 1;                                                                     /* u8 primitive->connectionConfig.ssid.length */
     bufferSize += 6;                                                                     /* u8 primitive->connectionConfig.bssid.a[6] */
@@ -328,7 +328,7 @@ CsrSize CsrWifiSmeConnectReqSizeof(void *msg)
     bufferSize += 1;                                                                     /* CsrWifiSme80211PrivacyMode primitive->connectionConfig.privacyMode */
     bufferSize += 2;                                                                     /* CsrWifiSmeAuthModeMask primitive->connectionConfig.authModeMask */
     bufferSize += 2;                                                                     /* CsrWifiSmeEncryptionMask primitive->connectionConfig.encryptionModeMask */
-    bufferSize += 2;                                                                     /* CsrUint16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
+    bufferSize += 2;                                                                     /* u16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
     bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* u8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
     bufferSize += 1;                                                                     /* CsrWifiSmeWmmQosInfoMask primitive->connectionConfig.wmmQosInfo */
     bufferSize += 1;                                                                     /* CsrBool primitive->connectionConfig.adhocJoinOnly */
@@ -342,19 +342,19 @@ u8* CsrWifiSmeConnectReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((CsrUint16) (32)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ssid.length);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.bssType);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ifIndex);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.privacyMode);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.authModeMask);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.encryptionModeMask);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.authModeMask);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.encryptionModeMask);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
     if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((u16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
     }
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.wmmQosInfo);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocJoinOnly);
@@ -370,20 +370,20 @@ void* CsrWifiSmeConnectReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->connectionConfig.bssType, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
     if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
     {
         primitive->connectionConfig.mlmeAssociateReqInformationElements = (u8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
-        CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+        CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((u16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
     }
     else
     {
@@ -410,9 +410,9 @@ CsrSize CsrWifiSmeHostConfigSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeHostPowerMode primitive->hostConfig.powerMode */
-    bufferSize += 2; /* CsrUint16 primitive->hostConfig.applicationDataPeriodMs */
+    bufferSize += 2; /* u16 primitive->hostConfig.applicationDataPeriodMs */
     return bufferSize;
 }
 
@@ -422,9 +422,9 @@ u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeHostConfigSetReq *primitive = (CsrWifiSmeHostConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->hostConfig.powerMode);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->hostConfig.applicationDataPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->hostConfig.applicationDataPeriodMs);
     return(ptr);
 }
 
@@ -436,9 +436,9 @@ void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->hostConfig.powerMode, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
 
     return primitive;
 }
@@ -449,16 +449,16 @@ CsrSize CsrWifiSmeKeyReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 65) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
     bufferSize += 1; /* CsrWifiSmeKeyType primitive->key.keyType */
     bufferSize += 1; /* u8 primitive->key.keyIndex */
     bufferSize += 1; /* CsrBool primitive->key.wepTxKey */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 8; i2++)
         {
-            bufferSize += 2; /* CsrUint16 primitive->key.keyRsc[8] */
+            bufferSize += 2; /* u16 primitive->key.keyRsc[8] */
         }
     }
     bufferSize += 1;         /* CsrBool primitive->key.authenticator */
@@ -474,22 +474,22 @@ u8* CsrWifiSmeKeyReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeKeyReq *primitive = (CsrWifiSmeKeyReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint8Ser(ptr, len, (u8) primitive->key.keyType);
     CsrUint8Ser(ptr, len, (u8) primitive->key.keyIndex);
     CsrUint8Ser(ptr, len, (u8) primitive->key.wepTxKey);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 8; i2++)
         {
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->key.keyRsc[i2]);
+            CsrUint16Ser(ptr, len, (u16) primitive->key.keyRsc[i2]);
         }
     }
     CsrUint8Ser(ptr, len, (u8) primitive->key.authenticator);
-    CsrMemCpySer(ptr, len, (const void *) primitive->key.address.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->key.address.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->key.keyLength);
-    CsrMemCpySer(ptr, len, (const void *) primitive->key.key, ((CsrUint16) (32)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->key.key, ((u16) (32)));
     return(ptr);
 }
 
@@ -501,22 +501,22 @@ void* CsrWifiSmeKeyReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->key.keyType, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->key.keyIndex, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->key.wepTxKey, buffer, &offset);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 8; i2++)
         {
-            CsrUint16Des((CsrUint16 *) &primitive->key.keyRsc[i2], buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->key.keyRsc[i2], buffer, &offset);
         }
     }
     CsrUint8Des((u8 *) &primitive->key.authenticator, buffer, &offset);
-    CsrMemCpyDes(primitive->key.address.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->key.address.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->key.keyLength, buffer, &offset);
-    CsrMemCpyDes(primitive->key.key, buffer, &offset, ((CsrUint16) (32)));
+    CsrMemCpyDes(primitive->key.key, buffer, &offset, ((u16) (32)));
 
     return primitive;
 }
@@ -529,9 +529,9 @@ CsrSize CsrWifiSmeMibConfigSetReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 1; /* CsrBool primitive->mibConfig.unifiFixMaxTxDataRate */
     bufferSize += 1; /* u8 primitive->mibConfig.unifiFixTxDataRate */
-    bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11RtsThreshold */
-    bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11FragmentationThreshold */
-    bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11CurrentTxPowerLevel */
+    bufferSize += 2; /* u16 primitive->mibConfig.dot11RtsThreshold */
+    bufferSize += 2; /* u16 primitive->mibConfig.dot11FragmentationThreshold */
+    bufferSize += 2; /* u16 primitive->mibConfig.dot11CurrentTxPowerLevel */
     return bufferSize;
 }
 
@@ -543,9 +543,9 @@ u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixMaxTxDataRate);
     CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixTxDataRate);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11RtsThreshold);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11FragmentationThreshold);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11CurrentTxPowerLevel);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11RtsThreshold);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11FragmentationThreshold);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11CurrentTxPowerLevel);
     return(ptr);
 }
 
@@ -559,9 +559,9 @@ void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixTxDataRate, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
 
     return primitive;
 }
@@ -573,7 +573,7 @@ CsrSize CsrWifiSmeMibGetNextReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
-    bufferSize += 2;                             /* CsrUint16 primitive->mibAttributeLength */
+    bufferSize += 2;                             /* u16 primitive->mibAttributeLength */
     bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
     return bufferSize;
 }
@@ -584,10 +584,10 @@ u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibAttributeLength);
     if (primitive->mibAttributeLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((u16) (primitive->mibAttributeLength)));
     }
     return(ptr);
 }
@@ -600,11 +600,11 @@ void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibAttributeLength, buffer, &offset);
     if (primitive->mibAttributeLength)
     {
         primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
-        CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+        CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((u16) (primitive->mibAttributeLength)));
     }
     else
     {
@@ -629,7 +629,7 @@ CsrSize CsrWifiSmeMibGetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
-    bufferSize += 2;                             /* CsrUint16 primitive->mibAttributeLength */
+    bufferSize += 2;                             /* u16 primitive->mibAttributeLength */
     bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
     return bufferSize;
 }
@@ -640,10 +640,10 @@ u8* CsrWifiSmeMibGetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibAttributeLength);
     if (primitive->mibAttributeLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((u16) (primitive->mibAttributeLength)));
     }
     return(ptr);
 }
@@ -656,11 +656,11 @@ void* CsrWifiSmeMibGetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibAttributeLength, buffer, &offset);
     if (primitive->mibAttributeLength)
     {
         primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
-        CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+        CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((u16) (primitive->mibAttributeLength)));
     }
     else
     {
@@ -685,7 +685,7 @@ CsrSize CsrWifiSmeMibSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
-    bufferSize += 2;                             /* CsrUint16 primitive->mibAttributeLength */
+    bufferSize += 2;                             /* u16 primitive->mibAttributeLength */
     bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
     return bufferSize;
 }
@@ -696,10 +696,10 @@ u8* CsrWifiSmeMibSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibAttributeLength);
     if (primitive->mibAttributeLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((u16) (primitive->mibAttributeLength)));
     }
     return(ptr);
 }
@@ -712,11 +712,11 @@ void* CsrWifiSmeMibSetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibAttributeLength, buffer, &offset);
     if (primitive->mibAttributeLength)
     {
         primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
-        CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+        CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((u16) (primitive->mibAttributeLength)));
     }
     else
     {
@@ -741,11 +741,11 @@ CsrSize CsrWifiSmeMulticastAddressReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
     bufferSize += 1; /* u8 primitive->setAddressesCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
         {
             bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
@@ -760,14 +760,14 @@ u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint8Ser(ptr, len, (u8) primitive->setAddressesCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((u16) (6)));
         }
     }
     return(ptr);
@@ -781,7 +781,7 @@ void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->setAddressesCount, buffer, &offset);
     primitive->setAddresses = NULL;
@@ -790,10 +790,10 @@ void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, CsrSize length)
         primitive->setAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->setAddressesCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
         {
-            CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((u16) (6)));
         }
     }
 
@@ -815,8 +815,8 @@ CsrSize CsrWifiSmePacketFilterSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
-    bufferSize += 2;                       /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 2;                       /* CsrUint16 primitive->filterLength */
+    bufferSize += 2;                       /* u16 primitive->interfaceTag */
+    bufferSize += 2;                       /* u16 primitive->filterLength */
     bufferSize += primitive->filterLength; /* u8 primitive->filter */
     bufferSize += 1;                       /* CsrWifiSmePacketFilterMode primitive->mode */
     bufferSize += 4;                       /* u8 primitive->arpFilterAddress.a[4] */
@@ -829,14 +829,14 @@ u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->filterLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->filterLength);
     if (primitive->filterLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->filter, ((CsrUint16) (primitive->filterLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->filter, ((u16) (primitive->filterLength)));
     }
     CsrUint8Ser(ptr, len, (u8) primitive->mode);
-    CsrMemCpySer(ptr, len, (const void *) primitive->arpFilterAddress.a, ((CsrUint16) (4)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->arpFilterAddress.a, ((u16) (4)));
     return(ptr);
 }
 
@@ -848,19 +848,19 @@ void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->filterLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->filterLength, buffer, &offset);
     if (primitive->filterLength)
     {
         primitive->filter = (u8 *)CsrPmemAlloc(primitive->filterLength);
-        CsrMemCpyDes(primitive->filter, buffer, &offset, ((CsrUint16) (primitive->filterLength)));
+        CsrMemCpyDes(primitive->filter, buffer, &offset, ((u16) (primitive->filterLength)));
     }
     else
     {
         primitive->filter = NULL;
     }
     CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
-    CsrMemCpyDes(primitive->arpFilterAddress.a, buffer, &offset, ((CsrUint16) (4)));
+    CsrMemCpyDes(primitive->arpFilterAddress.a, buffer, &offset, ((u16) (4)));
 
     return primitive;
 }
@@ -880,11 +880,11 @@ CsrSize CsrWifiSmePmkidReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 29) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
     bufferSize += 1; /* u8 primitive->setPmkidsCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
         {
             bufferSize += 6;  /* u8 primitive->setPmkids[i1].bssid.a[6] */
@@ -900,15 +900,15 @@ u8* CsrWifiSmePmkidReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint8Ser(ptr, len, (u8) primitive->setPmkidsCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->setPmkids[i1].bssid.a, ((CsrUint16) (6)));
-            CsrMemCpySer(ptr, len, (const void *) primitive->setPmkids[i1].pmkid, ((CsrUint16) (16)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->setPmkids[i1].bssid.a, ((u16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->setPmkids[i1].pmkid, ((u16) (16)));
         }
     }
     return(ptr);
@@ -922,7 +922,7 @@ void* CsrWifiSmePmkidReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->setPmkidsCount, buffer, &offset);
     primitive->setPmkids = NULL;
@@ -931,11 +931,11 @@ void* CsrWifiSmePmkidReqDes(u8 *buffer, CsrSize length)
         primitive->setPmkids = (CsrWifiSmePmkid *)CsrPmemAlloc(sizeof(CsrWifiSmePmkid) * primitive->setPmkidsCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
         {
-            CsrMemCpyDes(primitive->setPmkids[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
-            CsrMemCpyDes(primitive->setPmkids[i1].pmkid, buffer, &offset, ((CsrUint16) (16)));
+            CsrMemCpyDes(primitive->setPmkids[i1].bssid.a, buffer, &offset, ((u16) (6)));
+            CsrMemCpyDes(primitive->setPmkids[i1].pmkid, buffer, &offset, ((u16) (16)));
         }
     }
 
@@ -957,7 +957,7 @@ CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 1; /* CsrWifiSmePowerSaveLevel primitive->powerConfig.powerSaveLevel */
-    bufferSize += 2; /* CsrUint16 primitive->powerConfig.listenIntervalTu */
+    bufferSize += 2; /* u16 primitive->powerConfig.listenIntervalTu */
     bufferSize += 1; /* CsrBool primitive->powerConfig.rxDtims */
     bufferSize += 1; /* CsrWifiSmeD3AutoScanMode primitive->powerConfig.d3AutoScanMode */
     bufferSize += 1; /* u8 primitive->powerConfig.clientTrafficWindow */
@@ -973,7 +973,7 @@ u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.powerSaveLevel);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->powerConfig.listenIntervalTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->powerConfig.listenIntervalTu);
     CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.rxDtims);
     CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.d3AutoScanMode);
     CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.clientTrafficWindow);
@@ -991,7 +991,7 @@ void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
@@ -1007,9 +1007,9 @@ CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 70) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
             bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].rssiHighThreshold */
@@ -1021,17 +1021,17 @@ CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg)
     bufferSize += 1;         /* CsrBool primitive->roamingConfig.disableSmoothRoaming */
     bufferSize += 1;         /* CsrBool primitive->roamingConfig.disableRoamScans */
     bufferSize += 1;         /* u8 primitive->roamingConfig.reconnectLimit */
-    bufferSize += 2;         /* CsrUint16 primitive->roamingConfig.reconnectLimitIntervalMs */
+    bufferSize += 2;         /* u16 primitive->roamingConfig.reconnectLimitIntervalMs */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].intervalSeconds */
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].validitySeconds */
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu */
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu */
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu */
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].intervalSeconds */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].validitySeconds */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu */
         }
     }
     return bufferSize;
@@ -1043,31 +1043,31 @@ u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeRoamingConfigSetReq *primitive = (CsrWifiSmeRoamingConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiHighThreshold);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiLowThreshold);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrHighThreshold);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].rssiHighThreshold);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].rssiLowThreshold);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].snrHighThreshold);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
         }
     }
     CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableSmoothRoaming);
     CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableRoamScans);
     CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.reconnectLimit);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.reconnectLimitIntervalMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.reconnectLimitIntervalMs);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].intervalSeconds);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].validitySeconds);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].intervalSeconds);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].validitySeconds);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu);
         }
     }
     return(ptr);
@@ -1081,31 +1081,31 @@ void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiHighThreshold, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiLowThreshold, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrHighThreshold, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].rssiHighThreshold, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].rssiLowThreshold, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].snrHighThreshold, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
         }
     }
     CsrUint8Des((u8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->roamingConfig.reconnectLimit, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].intervalSeconds, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].validitySeconds, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].intervalSeconds, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].validitySeconds, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
         }
     }
 
@@ -1120,26 +1120,26 @@ CsrSize CsrWifiSmeScanConfigSetReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 63) */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].intervalSeconds */
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].validitySeconds */
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu */
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu */
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu */
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].intervalSeconds */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].validitySeconds */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu */
         }
     }
     bufferSize += 1;                                             /* CsrBool primitive->scanConfig.disableAutonomousScans */
-    bufferSize += 2;                                             /* CsrUint16 primitive->scanConfig.maxResults */
+    bufferSize += 2;                                             /* u16 primitive->scanConfig.maxResults */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.highRssiThreshold */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.lowRssiThreshold */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.deltaRssiThreshold */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.highSnrThreshold */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.lowSnrThreshold */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.deltaSnrThreshold */
-    bufferSize += 2;                                             /* CsrUint16 primitive->scanConfig.passiveChannelListCount */
+    bufferSize += 2;                                             /* u16 primitive->scanConfig.passiveChannelListCount */
     bufferSize += primitive->scanConfig.passiveChannelListCount; /* u8 primitive->scanConfig.passiveChannelList */
     return bufferSize;
 }
@@ -1151,29 +1151,29 @@ u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].intervalSeconds);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].validitySeconds);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].intervalSeconds);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].validitySeconds);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
         }
     }
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.disableAutonomousScans);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.maxResults);
+    CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.maxResults);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highRssiThreshold);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowRssiThreshold);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaRssiThreshold);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highSnrThreshold);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowSnrThreshold);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaSnrThreshold);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.passiveChannelListCount);
+    CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.passiveChannelListCount);
     if (primitive->scanConfig.passiveChannelListCount)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->scanConfig.passiveChannelList, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->scanConfig.passiveChannelList, ((u16) (primitive->scanConfig.passiveChannelListCount)));
     }
     return(ptr);
 }
@@ -1187,30 +1187,30 @@ void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].intervalSeconds, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].validitySeconds, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].intervalSeconds, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].validitySeconds, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
         }
     }
     CsrUint8Des((u8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->scanConfig.maxResults, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->scanConfig.maxResults, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.deltaSnrThreshold, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
     if (primitive->scanConfig.passiveChannelListCount)
     {
         primitive->scanConfig.passiveChannelList = (u8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
-        CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+        CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((u16) (primitive->scanConfig.passiveChannelListCount)));
     }
     else
     {
@@ -1237,7 +1237,7 @@ CsrSize CsrWifiSmeScanFullReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 52) */
     bufferSize += 1; /* u8 primitive->ssidCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->ssidCount; i1++)
         {
             bufferSize += 32;                  /* u8 primitive->ssid[i1].ssid[32] */
@@ -1248,9 +1248,9 @@ CsrSize CsrWifiSmeScanFullReqSizeof(void *msg)
     bufferSize += 1;                           /* CsrBool primitive->forceScan */
     bufferSize += 1;                           /* CsrWifiSmeBssType primitive->bssType */
     bufferSize += 1;                           /* CsrWifiSmeScanType primitive->scanType */
-    bufferSize += 2;                           /* CsrUint16 primitive->channelListCount */
+    bufferSize += 2;                           /* u16 primitive->channelListCount */
     bufferSize += primitive->channelListCount; /* u8 primitive->channelList */
-    bufferSize += 2;                           /* CsrUint16 primitive->probeIeLength */
+    bufferSize += 2;                           /* u16 primitive->probeIeLength */
     bufferSize += primitive->probeIeLength;    /* u8 primitive->probeIe */
     return bufferSize;
 }
@@ -1263,26 +1263,26 @@ u8* CsrWifiSmeScanFullReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint8Ser(ptr, len, (u8) primitive->ssidCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->ssidCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->ssid[i1].ssid, ((CsrUint16) (32)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->ssid[i1].ssid, ((u16) (32)));
             CsrUint8Ser(ptr, len, (u8) primitive->ssid[i1].length);
         }
     }
-    CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->forceScan);
     CsrUint8Ser(ptr, len, (u8) primitive->bssType);
     CsrUint8Ser(ptr, len, (u8) primitive->scanType);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->channelListCount);
+    CsrUint16Ser(ptr, len, (u16) primitive->channelListCount);
     if (primitive->channelListCount)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->channelList, ((CsrUint16) (primitive->channelListCount)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->channelList, ((u16) (primitive->channelListCount)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->probeIeLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->probeIeLength);
     if (primitive->probeIeLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->probeIe, ((CsrUint16) (primitive->probeIeLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->probeIe, ((u16) (primitive->probeIeLength)));
     }
     return(ptr);
 }
@@ -1302,32 +1302,32 @@ void* CsrWifiSmeScanFullReqDes(u8 *buffer, CsrSize length)
         primitive->ssid = (CsrWifiSsid *)CsrPmemAlloc(sizeof(CsrWifiSsid) * primitive->ssidCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->ssidCount; i1++)
         {
-            CsrMemCpyDes(primitive->ssid[i1].ssid, buffer, &offset, ((CsrUint16) (32)));
+            CsrMemCpyDes(primitive->ssid[i1].ssid, buffer, &offset, ((u16) (32)));
             CsrUint8Des((u8 *) &primitive->ssid[i1].length, buffer, &offset);
         }
     }
-    CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->forceScan, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->bssType, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanType, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->channelListCount, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->channelListCount, buffer, &offset);
     if (primitive->channelListCount)
     {
         primitive->channelList = (u8 *)CsrPmemAlloc(primitive->channelListCount);
-        CsrMemCpyDes(primitive->channelList, buffer, &offset, ((CsrUint16) (primitive->channelListCount)));
+        CsrMemCpyDes(primitive->channelList, buffer, &offset, ((u16) (primitive->channelListCount)));
     }
     else
     {
         primitive->channelList = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->probeIeLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->probeIeLength, buffer, &offset);
     if (primitive->probeIeLength)
     {
         primitive->probeIe = (u8 *)CsrPmemAlloc(primitive->probeIeLength);
-        CsrMemCpyDes(primitive->probeIe, buffer, &offset, ((CsrUint16) (primitive->probeIeLength)));
+        CsrMemCpyDes(primitive->probeIe, buffer, &offset, ((u16) (primitive->probeIeLength)));
     }
     else
     {
@@ -1353,7 +1353,7 @@ CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* u8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
     bufferSize += 1; /* u8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
     bufferSize += 1; /* CsrWifiSmeWmmModeMask primitive->smeConfig.wmmModeMask */
@@ -1369,7 +1369,7 @@ u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeSmeStaConfigSetReq *primitive = (CsrWifiSmeSmeStaConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
     CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
     CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.wmmModeMask);
@@ -1387,7 +1387,7 @@ void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
@@ -1405,14 +1405,14 @@ CsrSize CsrWifiSmeTspecReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
-    bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                      /* u16 primitive->interfaceTag */
     bufferSize += 1;                      /* CsrWifiSmeListAction primitive->action */
     bufferSize += 4;                      /* CsrUint32 primitive->transactionId */
     bufferSize += 1;                      /* CsrBool primitive->strict */
     bufferSize += 1;                      /* CsrWifiSmeTspecCtrlMask primitive->ctrlMask */
-    bufferSize += 2;                      /* CsrUint16 primitive->tspecLength */
+    bufferSize += 2;                      /* u16 primitive->tspecLength */
     bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
-    bufferSize += 2;                      /* CsrUint16 primitive->tclasLength */
+    bufferSize += 2;                      /* u16 primitive->tclasLength */
     bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
     return bufferSize;
 }
@@ -1423,20 +1423,20 @@ u8* CsrWifiSmeTspecReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
     CsrUint8Ser(ptr, len, (u8) primitive->strict);
     CsrUint8Ser(ptr, len, (u8) primitive->ctrlMask);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->tspecLength);
     if (primitive->tspecLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((CsrUint16) (primitive->tspecLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((u16) (primitive->tspecLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->tclasLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->tclasLength);
     if (primitive->tclasLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((CsrUint16) (primitive->tclasLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((u16) (primitive->tclasLength)));
     }
     return(ptr);
 }
@@ -1449,26 +1449,26 @@ void* CsrWifiSmeTspecReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->strict, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->ctrlMask, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->tspecLength, buffer, &offset);
     if (primitive->tspecLength)
     {
         primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
-        CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
+        CsrMemCpyDes(primitive->tspec, buffer, &offset, ((u16) (primitive->tspecLength)));
     }
     else
     {
         primitive->tspec = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->tclasLength, buffer, &offset);
     if (primitive->tclasLength)
     {
         primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
-        CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
+        CsrMemCpyDes(primitive->tclas, buffer, &offset, ((u16) (primitive->tclasLength)));
     }
     else
     {
@@ -1495,12 +1495,12 @@ CsrSize CsrWifiSmeWifiFlightmodeReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
     bufferSize += 6; /* u8 primitive->address.a[6] */
-    bufferSize += 2; /* CsrUint16 primitive->mibFilesCount */
+    bufferSize += 2; /* u16 primitive->mibFilesCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
         {
-            bufferSize += 2;                              /* CsrUint16 primitive->mibFiles[i1].length */
+            bufferSize += 2;                              /* u16 primitive->mibFiles[i1].length */
             bufferSize += primitive->mibFiles[i1].length; /* u8 primitive->mibFiles[i1].data */
         }
     }
@@ -1513,16 +1513,16 @@ u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFilesCount);
+    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->mibFilesCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
         {
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFiles[i1].length);
+            CsrUint16Ser(ptr, len, (u16) primitive->mibFiles[i1].length);
             if (primitive->mibFiles[i1].length)
             {
-                CsrMemCpySer(ptr, len, (const void *) primitive->mibFiles[i1].data, ((CsrUint16) (primitive->mibFiles[i1].length)));
+                CsrMemCpySer(ptr, len, (const void *) primitive->mibFiles[i1].data, ((u16) (primitive->mibFiles[i1].length)));
             }
         }
     }
@@ -1537,22 +1537,22 @@ void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint16Des((CsrUint16 *) &primitive->mibFilesCount, buffer, &offset);
+    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
+    CsrUint16Des((u16 *) &primitive->mibFilesCount, buffer, &offset);
     primitive->mibFiles = NULL;
     if (primitive->mibFilesCount)
     {
         primitive->mibFiles = (CsrWifiSmeDataBlock *)CsrPmemAlloc(sizeof(CsrWifiSmeDataBlock) * primitive->mibFilesCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
         {
-            CsrUint16Des((CsrUint16 *) &primitive->mibFiles[i1].length, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->mibFiles[i1].length, buffer, &offset);
             if (primitive->mibFiles[i1].length)
             {
                 primitive->mibFiles[i1].data = (u8 *)CsrPmemAlloc(primitive->mibFiles[i1].length);
-                CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((CsrUint16) (primitive->mibFiles[i1].length)));
+                CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((u16) (primitive->mibFiles[i1].length)));
             }
             else
             {
@@ -1569,7 +1569,7 @@ void CsrWifiSmeWifiFlightmodeReqSerFree(void *voidPrimitivePointer)
 {
     CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *) voidPrimitivePointer;
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
         {
             CsrPmemFree(primitive->mibFiles[i1].data);
@@ -1587,12 +1587,12 @@ CsrSize CsrWifiSmeWifiOnReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
     bufferSize += 6; /* u8 primitive->address.a[6] */
-    bufferSize += 2; /* CsrUint16 primitive->mibFilesCount */
+    bufferSize += 2; /* u16 primitive->mibFilesCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
         {
-            bufferSize += 2;                              /* CsrUint16 primitive->mibFiles[i1].length */
+            bufferSize += 2;                              /* u16 primitive->mibFiles[i1].length */
             bufferSize += primitive->mibFiles[i1].length; /* u8 primitive->mibFiles[i1].data */
         }
     }
@@ -1605,16 +1605,16 @@ u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFilesCount);
+    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->mibFilesCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
         {
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFiles[i1].length);
+            CsrUint16Ser(ptr, len, (u16) primitive->mibFiles[i1].length);
             if (primitive->mibFiles[i1].length)
             {
-                CsrMemCpySer(ptr, len, (const void *) primitive->mibFiles[i1].data, ((CsrUint16) (primitive->mibFiles[i1].length)));
+                CsrMemCpySer(ptr, len, (const void *) primitive->mibFiles[i1].data, ((u16) (primitive->mibFiles[i1].length)));
             }
         }
     }
@@ -1629,22 +1629,22 @@ void* CsrWifiSmeWifiOnReqDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint16Des((CsrUint16 *) &primitive->mibFilesCount, buffer, &offset);
+    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
+    CsrUint16Des((u16 *) &primitive->mibFilesCount, buffer, &offset);
     primitive->mibFiles = NULL;
     if (primitive->mibFilesCount)
     {
         primitive->mibFiles = (CsrWifiSmeDataBlock *)CsrPmemAlloc(sizeof(CsrWifiSmeDataBlock) * primitive->mibFilesCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
         {
-            CsrUint16Des((CsrUint16 *) &primitive->mibFiles[i1].length, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->mibFiles[i1].length, buffer, &offset);
             if (primitive->mibFiles[i1].length)
             {
                 primitive->mibFiles[i1].data = (u8 *)CsrPmemAlloc(primitive->mibFiles[i1].length);
-                CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((CsrUint16) (primitive->mibFiles[i1].length)));
+                CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((u16) (primitive->mibFiles[i1].length)));
             }
             else
             {
@@ -1661,7 +1661,7 @@ void CsrWifiSmeWifiOnReqSerFree(void *voidPrimitivePointer)
 {
     CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *) voidPrimitivePointer;
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
         {
             CsrPmemFree(primitive->mibFiles[i1].data);
@@ -1680,7 +1680,7 @@ CsrSize CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 37) */
     bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsidsCount */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
             bufferSize += 32; /* u8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
@@ -1698,10 +1698,10 @@ u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsidsCount);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((CsrUint16) (32)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((u16) (32)));
             CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsids[i2].length);
         }
     }
@@ -1723,10 +1723,10 @@ void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, CsrSize length)
         primitive->cloakedSsids.cloakedSsids = (CsrWifiSsid *)CsrPmemAlloc(sizeof(CsrWifiSsid) * primitive->cloakedSsids.cloakedSsidsCount);
     }
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
-            CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((CsrUint16) (32)));
+            CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((u16) (32)));
             CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
         }
     }
@@ -1762,7 +1762,7 @@ u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.trustLevel);
-    CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((CsrUint16) (2)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((u16) (2)));
     CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.firmwareDriverInterface);
     CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.enableStrictDraftN);
     return(ptr);
@@ -1777,7 +1777,7 @@ void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
-    CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((CsrUint16) (2)));
+    CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((u16) (2)));
     CsrUint8Des((u8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
 
@@ -1805,7 +1805,7 @@ CsrSize CsrWifiSmeWpsConfigurationReqSizeof(void *msg)
     bufferSize += 8;  /* u8 primitive->wpsConfig.primDeviceType.deviceDetails[8] */
     bufferSize += 1;  /* u8 primitive->wpsConfig.secondaryDeviceTypeCount */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
         {
             bufferSize += 8; /* u8 primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails[8] */
@@ -1824,28 +1824,28 @@ u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, CsrSize *len, void *msg)
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.wpsVersion);
-    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.uuid, ((CsrUint16) (16)));
-    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.deviceName, ((CsrUint16) (32)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.uuid, ((u16) (16)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.deviceName, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.deviceNameLength);
-    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.manufacturer, ((CsrUint16) (64)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.manufacturer, ((u16) (64)));
     CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.manufacturerLength);
-    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelName, ((CsrUint16) (32)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelName, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.modelNameLength);
-    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelNumber, ((CsrUint16) (32)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelNumber, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.modelNumberLength);
-    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.serialNumber, ((CsrUint16) (32)));
-    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.serialNumber, ((u16) (32)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.primDeviceType.deviceDetails, ((u16) (8)));
     CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.secondaryDeviceTypeCount);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails, ((CsrUint16) (8)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails, ((u16) (8)));
         }
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->wpsConfig.configMethods);
+    CsrUint16Ser(ptr, len, (u16) primitive->wpsConfig.configMethods);
     CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.rfBands);
-    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.osVersion, ((CsrUint16) (4)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.osVersion, ((u16) (4)));
     return(ptr);
 }
 
@@ -1858,17 +1858,17 @@ void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->wpsConfig.wpsVersion, buffer, &offset);
-    CsrMemCpyDes(primitive->wpsConfig.uuid, buffer, &offset, ((CsrUint16) (16)));
-    CsrMemCpyDes(primitive->wpsConfig.deviceName, buffer, &offset, ((CsrUint16) (32)));
+    CsrMemCpyDes(primitive->wpsConfig.uuid, buffer, &offset, ((u16) (16)));
+    CsrMemCpyDes(primitive->wpsConfig.deviceName, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->wpsConfig.deviceNameLength, buffer, &offset);
-    CsrMemCpyDes(primitive->wpsConfig.manufacturer, buffer, &offset, ((CsrUint16) (64)));
+    CsrMemCpyDes(primitive->wpsConfig.manufacturer, buffer, &offset, ((u16) (64)));
     CsrUint8Des((u8 *) &primitive->wpsConfig.manufacturerLength, buffer, &offset);
-    CsrMemCpyDes(primitive->wpsConfig.modelName, buffer, &offset, ((CsrUint16) (32)));
+    CsrMemCpyDes(primitive->wpsConfig.modelName, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->wpsConfig.modelNameLength, buffer, &offset);
-    CsrMemCpyDes(primitive->wpsConfig.modelNumber, buffer, &offset, ((CsrUint16) (32)));
+    CsrMemCpyDes(primitive->wpsConfig.modelNumber, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->wpsConfig.modelNumberLength, buffer, &offset);
-    CsrMemCpyDes(primitive->wpsConfig.serialNumber, buffer, &offset, ((CsrUint16) (32)));
-    CsrMemCpyDes(primitive->wpsConfig.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+    CsrMemCpyDes(primitive->wpsConfig.serialNumber, buffer, &offset, ((u16) (32)));
+    CsrMemCpyDes(primitive->wpsConfig.primDeviceType.deviceDetails, buffer, &offset, ((u16) (8)));
     CsrUint8Des((u8 *) &primitive->wpsConfig.secondaryDeviceTypeCount, buffer, &offset);
     primitive->wpsConfig.secondaryDeviceType = NULL;
     if (primitive->wpsConfig.secondaryDeviceTypeCount)
@@ -1876,15 +1876,15 @@ void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, CsrSize length)
         primitive->wpsConfig.secondaryDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->wpsConfig.secondaryDeviceTypeCount);
     }
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
         {
-            CsrMemCpyDes(primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+            CsrMemCpyDes(primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails, buffer, &offset, ((u16) (8)));
         }
     }
-    CsrUint16Des((CsrUint16 *) &primitive->wpsConfig.configMethods, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->wpsConfig.configMethods, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->wpsConfig.rfBands, buffer, &offset);
-    CsrMemCpyDes(primitive->wpsConfig.osVersion, buffer, &offset, ((CsrUint16) (4)));
+    CsrMemCpyDes(primitive->wpsConfig.osVersion, buffer, &offset, ((u16) (4)));
 
     return primitive;
 }
@@ -1918,7 +1918,7 @@ u8* CsrWifiSmeSetReqSer(u8 *ptr, CsrSize *len, void *msg)
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
     if (primitive->dataLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
     }
     return(ptr);
 }
@@ -1935,7 +1935,7 @@ void* CsrWifiSmeSetReqDes(u8 *buffer, CsrSize length)
     if (primitive->dataLength)
     {
         primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
-        CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
     }
     else
     {
@@ -1960,10 +1960,10 @@ CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 2; /* CsrUint16 primitive->adHocConfig.atimWindowTu */
-    bufferSize += 2; /* CsrUint16 primitive->adHocConfig.beaconPeriodTu */
-    bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinOnlyAttempts */
-    bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinAttemptIntervalMs */
+    bufferSize += 2; /* u16 primitive->adHocConfig.atimWindowTu */
+    bufferSize += 2; /* u16 primitive->adHocConfig.beaconPeriodTu */
+    bufferSize += 2; /* u16 primitive->adHocConfig.joinOnlyAttempts */
+    bufferSize += 2; /* u16 primitive->adHocConfig.joinAttemptIntervalMs */
     return bufferSize;
 }
 
@@ -1973,11 +1973,11 @@ u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeAdhocConfigGetCfm *primitive = (CsrWifiSmeAdhocConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.atimWindowTu);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.beaconPeriodTu);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinOnlyAttempts);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinAttemptIntervalMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.atimWindowTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.beaconPeriodTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.joinOnlyAttempts);
+    CsrUint16Ser(ptr, len, (u16) primitive->adHocConfig.joinAttemptIntervalMs);
     return(ptr);
 }
 
@@ -1989,11 +1989,11 @@ void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.atimWindowTu, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.beaconPeriodTu, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinOnlyAttempts, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinAttemptIntervalMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->adHocConfig.atimWindowTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->adHocConfig.beaconPeriodTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->adHocConfig.joinOnlyAttempts, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->adHocConfig.joinAttemptIntervalMs, buffer, &offset);
 
     return primitive;
 }
@@ -2005,38 +2005,38 @@ CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 98) */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                                                     /* u16 primitive->interfaceTag */
     bufferSize += 2;                                                     /* CsrResult primitive->status */
     bufferSize += 32;                                                    /* u8 primitive->connectionInfo.ssid.ssid[32] */
     bufferSize += 1;                                                     /* u8 primitive->connectionInfo.ssid.length */
     bufferSize += 6;                                                     /* u8 primitive->connectionInfo.bssid.a[6] */
     bufferSize += 1;                                                     /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
     bufferSize += 1;                                                     /* u8 primitive->connectionInfo.channelNumber */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.channelFrequency */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.channelFrequency */
     bufferSize += 2;                                                     /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
     bufferSize += 2;                                                     /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
     bufferSize += 2;                                                     /* CsrWifiSmeEncryption primitive->connectionInfo.groupCipher */
     bufferSize += 1;                                                     /* CsrWifiSmeRadioIF primitive->connectionInfo.ifIndex */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.atimWindowTu */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.atimWindowTu */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.beaconPeriodTu */
     bufferSize += 1;                                                     /* CsrBool primitive->connectionInfo.reassociation */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.beaconFrameLength */
     bufferSize += primitive->connectionInfo.beaconFrameLength;           /* u8 primitive->connectionInfo.beaconFrame */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.associationReqFrameLength */
     bufferSize += primitive->connectionInfo.associationReqFrameLength;   /* u8 primitive->connectionInfo.associationReqFrame */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.associationRspFrameLength */
     bufferSize += primitive->connectionInfo.associationRspFrameLength;   /* u8 primitive->connectionInfo.associationRspFrame */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocScanInfoElementsLength */
     bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocReqCapabilities */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocReqListenIntervalTu */
     bufferSize += 6;                                                     /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocReqInfoElementsLength */
     bufferSize += primitive->connectionInfo.assocReqInfoElementsLength;  /* u8 primitive->connectionInfo.assocReqInfoElements */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocRspCapabilityInfo */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocRspAssociationId */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocRspInfoElementsLength */
     bufferSize += primitive->connectionInfo.assocRspInfoElementsLength;  /* u8 primitive->connectionInfo.assocRspInfoElements */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Reason primitive->deauthReason */
     return bufferSize;
@@ -2048,58 +2048,58 @@ u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.networkType80211);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.channelNumber);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.channelFrequency);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.authMode);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.pairwiseCipher);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.groupCipher);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.atimWindowTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconPeriodTu);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconFrameLength);
     if (primitive->connectionInfo.beaconFrameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((u16) (primitive->connectionInfo.beaconFrameLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationReqFrameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationReqFrameLength);
     if (primitive->connectionInfo.associationReqFrameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationRspFrameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationRspFrameLength);
     if (primitive->connectionInfo.associationRspFrameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocScanInfoElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocScanInfoElementsLength);
     if (primitive->connectionInfo.assocScanInfoElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqCapabilities);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqListenIntervalTu);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((CsrUint16) (6)));
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqInfoElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqCapabilities);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqListenIntervalTu);
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((u16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqInfoElementsLength);
     if (primitive->connectionInfo.assocReqInfoElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspResult);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspCapabilityInfo);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspAssociationId);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspInfoElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspResult);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspCapabilityInfo);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspAssociationId);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspInfoElementsLength);
     if (primitive->connectionInfo.assocRspInfoElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->deauthReason);
+    CsrUint16Ser(ptr, len, (u16) primitive->deauthReason);
     return(ptr);
 }
 
@@ -2111,88 +2111,88 @@ void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.authMode, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
     if (primitive->connectionInfo.beaconFrameLength)
     {
         primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
-        CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+        CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((u16) (primitive->connectionInfo.beaconFrameLength)));
     }
     else
     {
         primitive->connectionInfo.beaconFrame = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationReqFrameLength)
     {
         primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
-        CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+        CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
     }
     else
     {
         primitive->connectionInfo.associationReqFrame = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationRspFrameLength)
     {
         primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
-        CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+        CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
     }
     else
     {
         primitive->connectionInfo.associationRspFrame = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocScanInfoElementsLength)
     {
         primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
-        CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+        CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
     }
     else
     {
         primitive->connectionInfo.assocScanInfoElements = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
+    CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((u16) (6)));
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocReqInfoElementsLength)
     {
         primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
-        CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+        CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
     }
     else
     {
         primitive->connectionInfo.assocReqInfoElements = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocRspInfoElementsLength)
     {
         primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
-        CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+        CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
     }
     else
     {
         primitive->connectionInfo.assocRspInfoElements = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->deauthReason, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->deauthReason, buffer, &offset);
 
     return primitive;
 }
@@ -2216,7 +2216,7 @@ CsrSize CsrWifiSmeAssociationStartIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 44) */
-    bufferSize += 2;  /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;  /* u16 primitive->interfaceTag */
     bufferSize += 6;  /* u8 primitive->address.a[6] */
     bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
     bufferSize += 1;  /* u8 primitive->ssid.length */
@@ -2229,9 +2229,9 @@ u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeAssociationStartInd *primitive = (CsrWifiSmeAssociationStartInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
-    CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
     return(ptr);
 }
@@ -2244,9 +2244,9 @@ void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
+    CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
 
     return primitive;
@@ -2259,12 +2259,12 @@ CsrSize CsrWifiSmeBlacklistCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
     bufferSize += 1; /* u8 primitive->getAddressCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getAddressCount; i1++)
         {
             bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
@@ -2279,15 +2279,15 @@ u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint8Ser(ptr, len, (u8) primitive->getAddressCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getAddressCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((u16) (6)));
         }
     }
     return(ptr);
@@ -2301,8 +2301,8 @@ void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->getAddressCount, buffer, &offset);
     primitive->getAddresses = NULL;
@@ -2311,10 +2311,10 @@ void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, CsrSize length)
         primitive->getAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->getAddressCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getAddressCount; i1++)
         {
-            CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((u16) (6)));
         }
     }
 
@@ -2337,7 +2337,7 @@ CsrSize CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2;                                /* CsrResult primitive->status */
-    bufferSize += 2;                                /* CsrUint16 primitive->calibrationDataLength */
+    bufferSize += 2;                                /* u16 primitive->calibrationDataLength */
     bufferSize += primitive->calibrationDataLength; /* u8 primitive->calibrationData */
     return bufferSize;
 }
@@ -2348,11 +2348,11 @@ u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->calibrationDataLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->calibrationDataLength);
     if (primitive->calibrationDataLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->calibrationData, ((CsrUint16) (primitive->calibrationDataLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->calibrationData, ((u16) (primitive->calibrationDataLength)));
     }
     return(ptr);
 }
@@ -2365,12 +2365,12 @@ void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->calibrationDataLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->calibrationDataLength, buffer, &offset);
     if (primitive->calibrationDataLength)
     {
         primitive->calibrationData = (u8 *)CsrPmemAlloc(primitive->calibrationDataLength);
-        CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((CsrUint16) (primitive->calibrationDataLength)));
+        CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((u16) (primitive->calibrationDataLength)));
     }
     else
     {
@@ -2394,7 +2394,7 @@ CsrSize CsrWifiSmeCcxConfigGetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* u8 primitive->ccxConfig.keepAliveTimeMs */
     bufferSize += 1; /* CsrBool primitive->ccxConfig.apRoamingEnabled */
@@ -2409,8 +2409,8 @@ u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeCcxConfigGetCfm *primitive = (CsrWifiSmeCcxConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.keepAliveTimeMs);
     CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.apRoamingEnabled);
     CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.measurementsMask);
@@ -2426,8 +2426,8 @@ void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
@@ -2442,7 +2442,7 @@ CsrSize CsrWifiSmeCcxConfigSetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -2453,8 +2453,8 @@ u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeCcxConfigSetCfm *primitive = (CsrWifiSmeCcxConfigSetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -2466,8 +2466,8 @@ void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -2481,18 +2481,18 @@ CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg)
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrBool primitive->coexConfig.coexEnableSchemeManagement */
     bufferSize += 1; /* CsrBool primitive->coexConfig.coexPeriodicWakeHost */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficBurstyLatencyMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficContinuousLatencyMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutDurationMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutPeriodMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutDurationMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutPeriodMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutDurationMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutDurationMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutPeriodMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutDurationMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexTrafficBurstyLatencyMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexTrafficContinuousLatencyMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexObexBlackoutDurationMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexObexBlackoutPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpBrBlackoutDurationMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpBrBlackoutPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpEdrBlackoutDurationMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexPagingBlackoutDurationMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexPagingBlackoutPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexInquiryBlackoutDurationMs */
+    bufferSize += 2; /* u16 primitive->coexConfig.coexInquiryBlackoutPeriodMs */
     return bufferSize;
 }
 
@@ -2502,21 +2502,21 @@ u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeCoexConfigGetCfm *primitive = (CsrWifiSmeCoexConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexEnableSchemeManagement);
     CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexPeriodicWakeHost);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutDurationMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutPeriodMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutDurationMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutPeriodMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutDurationMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutDurationMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutPeriodMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutDurationMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexObexBlackoutDurationMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexObexBlackoutPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpBrBlackoutDurationMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpBrBlackoutPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpEdrBlackoutDurationMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexPagingBlackoutDurationMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexPagingBlackoutPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexInquiryBlackoutDurationMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexConfig.coexInquiryBlackoutPeriodMs);
     return(ptr);
 }
 
@@ -2528,21 +2528,21 @@ void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->coexConfig.coexPeriodicWakeHost, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutPeriodMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutDurationMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutPeriodMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutDurationMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutDurationMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutPeriodMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutDurationMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexObexBlackoutPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpBrBlackoutDurationMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpBrBlackoutPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpEdrBlackoutDurationMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexPagingBlackoutDurationMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexPagingBlackoutPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexInquiryBlackoutDurationMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexConfig.coexInquiryBlackoutPeriodMs, buffer, &offset);
 
     return primitive;
 }
@@ -2556,10 +2556,10 @@ CsrSize CsrWifiSmeCoexInfoGetCfmSizeof(void *msg)
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrBool primitive->coexInfo.hasTrafficData */
     bufferSize += 1; /* CsrWifiSmeTrafficType primitive->coexInfo.currentTrafficType */
-    bufferSize += 2; /* CsrUint16 primitive->coexInfo.currentPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexInfo.currentPeriodMs */
     bufferSize += 1; /* CsrWifiSmePowerSaveLevel primitive->coexInfo.currentPowerSave */
-    bufferSize += 2; /* CsrUint16 primitive->coexInfo.currentCoexPeriodMs */
-    bufferSize += 2; /* CsrUint16 primitive->coexInfo.currentCoexLatencyMs */
+    bufferSize += 2; /* u16 primitive->coexInfo.currentCoexPeriodMs */
+    bufferSize += 2; /* u16 primitive->coexInfo.currentCoexLatencyMs */
     bufferSize += 1; /* CsrBool primitive->coexInfo.hasBtDevice */
     bufferSize += 4; /* CsrUint32 primitive->coexInfo.currentBlackoutDurationUs */
     bufferSize += 4; /* CsrUint32 primitive->coexInfo.currentBlackoutPeriodUs */
@@ -2573,13 +2573,13 @@ u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeCoexInfoGetCfm *primitive = (CsrWifiSmeCoexInfoGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.hasTrafficData);
     CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentTrafficType);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexInfo.currentPeriodMs);
     CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentPowerSave);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentCoexPeriodMs);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentCoexLatencyMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexInfo.currentCoexPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->coexInfo.currentCoexLatencyMs);
     CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.hasBtDevice);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->coexInfo.currentBlackoutDurationUs);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->coexInfo.currentBlackoutPeriodUs);
@@ -2595,13 +2595,13 @@ void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->coexInfo.hasTrafficData, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->coexInfo.currentTrafficType, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexInfo.currentPeriodMs, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->coexInfo.currentPowerSave, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentCoexPeriodMs, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentCoexLatencyMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexInfo.currentCoexPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->coexInfo.currentCoexLatencyMs, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->coexInfo.hasBtDevice, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->coexInfo.currentBlackoutDurationUs, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->coexInfo.currentBlackoutPeriodUs, buffer, &offset);
@@ -2616,7 +2616,7 @@ CsrSize CsrWifiSmeConnectCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -2627,8 +2627,8 @@ u8* CsrWifiSmeConnectCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeConnectCfm *primitive = (CsrWifiSmeConnectCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -2640,8 +2640,8 @@ void* CsrWifiSmeConnectCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -2653,7 +2653,7 @@ CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 59) */
-    bufferSize += 2;                                                                     /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                                                                     /* u16 primitive->interfaceTag */
     bufferSize += 2;                                                                     /* CsrResult primitive->status */
     bufferSize += 32;                                                                    /* u8 primitive->connectionConfig.ssid.ssid[32] */
     bufferSize += 1;                                                                     /* u8 primitive->connectionConfig.ssid.length */
@@ -2663,7 +2663,7 @@ CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg)
     bufferSize += 1;                                                                     /* CsrWifiSme80211PrivacyMode primitive->connectionConfig.privacyMode */
     bufferSize += 2;                                                                     /* CsrWifiSmeAuthModeMask primitive->connectionConfig.authModeMask */
     bufferSize += 2;                                                                     /* CsrWifiSmeEncryptionMask primitive->connectionConfig.encryptionModeMask */
-    bufferSize += 2;                                                                     /* CsrUint16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
+    bufferSize += 2;                                                                     /* u16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
     bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* u8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
     bufferSize += 1;                                                                     /* CsrWifiSmeWmmQosInfoMask primitive->connectionConfig.wmmQosInfo */
     bufferSize += 1;                                                                     /* CsrBool primitive->connectionConfig.adhocJoinOnly */
@@ -2677,20 +2677,20 @@ u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((CsrUint16) (32)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ssid.length);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.bssType);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ifIndex);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.privacyMode);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.authModeMask);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.encryptionModeMask);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.authModeMask);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.encryptionModeMask);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
     if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((u16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
     }
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.wmmQosInfo);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocJoinOnly);
@@ -2706,21 +2706,21 @@ void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->connectionConfig.bssType, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
     if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
     {
         primitive->connectionConfig.mlmeAssociateReqInformationElements = (u8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
-        CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+        CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((u16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
     }
     else
     {
@@ -2748,38 +2748,38 @@ CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 96) */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                                                     /* u16 primitive->interfaceTag */
     bufferSize += 2;                                                     /* CsrResult primitive->status */
     bufferSize += 32;                                                    /* u8 primitive->connectionInfo.ssid.ssid[32] */
     bufferSize += 1;                                                     /* u8 primitive->connectionInfo.ssid.length */
     bufferSize += 6;                                                     /* u8 primitive->connectionInfo.bssid.a[6] */
     bufferSize += 1;                                                     /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
     bufferSize += 1;                                                     /* u8 primitive->connectionInfo.channelNumber */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.channelFrequency */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.channelFrequency */
     bufferSize += 2;                                                     /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
     bufferSize += 2;                                                     /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
     bufferSize += 2;                                                     /* CsrWifiSmeEncryption primitive->connectionInfo.groupCipher */
     bufferSize += 1;                                                     /* CsrWifiSmeRadioIF primitive->connectionInfo.ifIndex */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.atimWindowTu */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.atimWindowTu */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.beaconPeriodTu */
     bufferSize += 1;                                                     /* CsrBool primitive->connectionInfo.reassociation */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.beaconFrameLength */
     bufferSize += primitive->connectionInfo.beaconFrameLength;           /* u8 primitive->connectionInfo.beaconFrame */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.associationReqFrameLength */
     bufferSize += primitive->connectionInfo.associationReqFrameLength;   /* u8 primitive->connectionInfo.associationReqFrame */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.associationRspFrameLength */
     bufferSize += primitive->connectionInfo.associationRspFrameLength;   /* u8 primitive->connectionInfo.associationRspFrame */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocScanInfoElementsLength */
     bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocReqCapabilities */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocReqListenIntervalTu */
     bufferSize += 6;                                                     /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocReqInfoElementsLength */
     bufferSize += primitive->connectionInfo.assocReqInfoElementsLength;  /* u8 primitive->connectionInfo.assocReqInfoElements */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocRspCapabilityInfo */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocRspAssociationId */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocRspInfoElementsLength */
     bufferSize += primitive->connectionInfo.assocRspInfoElementsLength;  /* u8 primitive->connectionInfo.assocRspInfoElements */
     return bufferSize;
 }
@@ -2790,56 +2790,56 @@ u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.networkType80211);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.channelNumber);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.channelFrequency);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.authMode);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.pairwiseCipher);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.groupCipher);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.atimWindowTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconPeriodTu);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconFrameLength);
     if (primitive->connectionInfo.beaconFrameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((u16) (primitive->connectionInfo.beaconFrameLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationReqFrameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationReqFrameLength);
     if (primitive->connectionInfo.associationReqFrameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationRspFrameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationRspFrameLength);
     if (primitive->connectionInfo.associationRspFrameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocScanInfoElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocScanInfoElementsLength);
     if (primitive->connectionInfo.assocScanInfoElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqCapabilities);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqListenIntervalTu);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((CsrUint16) (6)));
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqInfoElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqCapabilities);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqListenIntervalTu);
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((u16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqInfoElementsLength);
     if (primitive->connectionInfo.assocReqInfoElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspResult);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspCapabilityInfo);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspAssociationId);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspInfoElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspResult);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspCapabilityInfo);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspAssociationId);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspInfoElementsLength);
     if (primitive->connectionInfo.assocRspInfoElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
     }
     return(ptr);
 }
@@ -2852,82 +2852,82 @@ void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.authMode, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
     if (primitive->connectionInfo.beaconFrameLength)
     {
         primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
-        CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+        CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((u16) (primitive->connectionInfo.beaconFrameLength)));
     }
     else
     {
         primitive->connectionInfo.beaconFrame = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationReqFrameLength)
     {
         primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
-        CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+        CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
     }
     else
     {
         primitive->connectionInfo.associationReqFrame = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationRspFrameLength)
     {
         primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
-        CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+        CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
     }
     else
     {
         primitive->connectionInfo.associationRspFrame = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocScanInfoElementsLength)
     {
         primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
-        CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+        CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
     }
     else
     {
         primitive->connectionInfo.assocScanInfoElements = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
+    CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((u16) (6)));
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocReqInfoElementsLength)
     {
         primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
-        CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+        CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
     }
     else
     {
         primitive->connectionInfo.assocReqInfoElements = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocRspInfoElementsLength)
     {
         primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
-        CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+        CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
     }
     else
     {
@@ -2956,7 +2956,7 @@ CsrSize CsrWifiSmeConnectionQualityIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiRssi */
     bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiSnr */
     return bufferSize;
@@ -2968,9 +2968,9 @@ u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeConnectionQualityInd *primitive = (CsrWifiSmeConnectionQualityInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiRssi);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiSnr);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->linkQuality.unifiRssi);
+    CsrUint16Ser(ptr, len, (u16) primitive->linkQuality.unifiSnr);
     return(ptr);
 }
 
@@ -2982,9 +2982,9 @@ void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiRssi, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiSnr, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->linkQuality.unifiRssi, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->linkQuality.unifiSnr, buffer, &offset);
 
     return primitive;
 }
@@ -2995,7 +2995,7 @@ CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 101) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* u8 primitive->connectionStats.unifiTxDataRate */
     bufferSize += 1; /* u8 primitive->connectionStats.unifiRxDataRate */
@@ -3031,8 +3031,8 @@ u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeConnectionStatsGetCfm *primitive = (CsrWifiSmeConnectionStatsGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionStats.unifiTxDataRate);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionStats.unifiRxDataRate);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RetryCount);
@@ -3069,8 +3069,8 @@ void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionStats.unifiTxDataRate, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionStats.unifiRxDataRate, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RetryCount, buffer, &offset);
@@ -3106,7 +3106,7 @@ CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -3117,8 +3117,8 @@ u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeDisconnectCfm *primitive = (CsrWifiSmeDisconnectCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -3130,8 +3130,8 @@ void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -3142,10 +3142,10 @@ CsrSize CsrWifiSmeHostConfigGetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSmeHostPowerMode primitive->hostConfig.powerMode */
-    bufferSize += 2; /* CsrUint16 primitive->hostConfig.applicationDataPeriodMs */
+    bufferSize += 2; /* u16 primitive->hostConfig.applicationDataPeriodMs */
     return bufferSize;
 }
 
@@ -3155,10 +3155,10 @@ u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeHostConfigGetCfm *primitive = (CsrWifiSmeHostConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->hostConfig.powerMode);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->hostConfig.applicationDataPeriodMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->hostConfig.applicationDataPeriodMs);
     return(ptr);
 }
 
@@ -3170,10 +3170,10 @@ void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->hostConfig.powerMode, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
 
     return primitive;
 }
@@ -3184,7 +3184,7 @@ CsrSize CsrWifiSmeHostConfigSetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -3195,8 +3195,8 @@ u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeHostConfigSetCfm *primitive = (CsrWifiSmeHostConfigSetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -3208,8 +3208,8 @@ void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -3231,7 +3231,7 @@ u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeIbssStationInd *primitive = (CsrWifiSmeIbssStationInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->isconnected);
     return(ptr);
 }
@@ -3244,7 +3244,7 @@ void* CsrWifiSmeIbssStationIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->isconnected, buffer, &offset);
 
     return primitive;
@@ -3256,7 +3256,7 @@ CsrSize CsrWifiSmeKeyCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
     bufferSize += 1; /* CsrWifiSmeKeyType primitive->keyType */
@@ -3270,11 +3270,11 @@ u8* CsrWifiSmeKeyCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeKeyCfm *primitive = (CsrWifiSmeKeyCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint8Ser(ptr, len, (u8) primitive->keyType);
-    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((u16) (6)));
     return(ptr);
 }
 
@@ -3286,11 +3286,11 @@ void* CsrWifiSmeKeyCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->keyType, buffer, &offset);
-    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((u16) (6)));
 
     return primitive;
 }
@@ -3301,7 +3301,7 @@ CsrSize CsrWifiSmeLinkQualityGetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiRssi */
     bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiSnr */
@@ -3314,10 +3314,10 @@ u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeLinkQualityGetCfm *primitive = (CsrWifiSmeLinkQualityGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiRssi);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiSnr);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->linkQuality.unifiRssi);
+    CsrUint16Ser(ptr, len, (u16) primitive->linkQuality.unifiSnr);
     return(ptr);
 }
 
@@ -3329,10 +3329,10 @@ void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiRssi, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiSnr, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->linkQuality.unifiRssi, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->linkQuality.unifiSnr, buffer, &offset);
 
     return primitive;
 }
@@ -3344,38 +3344,38 @@ CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 99) */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                                                     /* u16 primitive->interfaceTag */
     bufferSize += 1;                                                     /* CsrWifiSmeMediaStatus primitive->mediaStatus */
     bufferSize += 32;                                                    /* u8 primitive->connectionInfo.ssid.ssid[32] */
     bufferSize += 1;                                                     /* u8 primitive->connectionInfo.ssid.length */
     bufferSize += 6;                                                     /* u8 primitive->connectionInfo.bssid.a[6] */
     bufferSize += 1;                                                     /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
     bufferSize += 1;                                                     /* u8 primitive->connectionInfo.channelNumber */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.channelFrequency */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.channelFrequency */
     bufferSize += 2;                                                     /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
     bufferSize += 2;                                                     /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
     bufferSize += 2;                                                     /* CsrWifiSmeEncryption primitive->connectionInfo.groupCipher */
     bufferSize += 1;                                                     /* CsrWifiSmeRadioIF primitive->connectionInfo.ifIndex */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.atimWindowTu */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.atimWindowTu */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.beaconPeriodTu */
     bufferSize += 1;                                                     /* CsrBool primitive->connectionInfo.reassociation */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.beaconFrameLength */
     bufferSize += primitive->connectionInfo.beaconFrameLength;           /* u8 primitive->connectionInfo.beaconFrame */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.associationReqFrameLength */
     bufferSize += primitive->connectionInfo.associationReqFrameLength;   /* u8 primitive->connectionInfo.associationReqFrame */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.associationRspFrameLength */
     bufferSize += primitive->connectionInfo.associationRspFrameLength;   /* u8 primitive->connectionInfo.associationRspFrame */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocScanInfoElementsLength */
     bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocReqCapabilities */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocReqListenIntervalTu */
     bufferSize += 6;                                                     /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocReqInfoElementsLength */
     bufferSize += primitive->connectionInfo.assocReqInfoElementsLength;  /* u8 primitive->connectionInfo.assocReqInfoElements */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
-    bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocRspCapabilityInfo */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocRspAssociationId */
+    bufferSize += 2;                                                     /* u16 primitive->connectionInfo.assocRspInfoElementsLength */
     bufferSize += primitive->connectionInfo.assocRspInfoElementsLength;  /* u8 primitive->connectionInfo.assocRspInfoElements */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Reason primitive->disassocReason */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Reason primitive->deauthReason */
@@ -3388,59 +3388,59 @@ u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.networkType80211);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.channelNumber);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.channelFrequency);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.authMode);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.pairwiseCipher);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.groupCipher);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.atimWindowTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconPeriodTu);
     CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.beaconFrameLength);
     if (primitive->connectionInfo.beaconFrameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((u16) (primitive->connectionInfo.beaconFrameLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationReqFrameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationReqFrameLength);
     if (primitive->connectionInfo.associationReqFrameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationRspFrameLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.associationRspFrameLength);
     if (primitive->connectionInfo.associationRspFrameLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocScanInfoElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocScanInfoElementsLength);
     if (primitive->connectionInfo.assocScanInfoElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqCapabilities);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqListenIntervalTu);
-    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((CsrUint16) (6)));
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqInfoElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqCapabilities);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqListenIntervalTu);
+    CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((u16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocReqInfoElementsLength);
     if (primitive->connectionInfo.assocReqInfoElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspResult);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspCapabilityInfo);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspAssociationId);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspInfoElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspResult);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspCapabilityInfo);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspAssociationId);
+    CsrUint16Ser(ptr, len, (u16) primitive->connectionInfo.assocRspInfoElementsLength);
     if (primitive->connectionInfo.assocRspInfoElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
     }
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->disassocReason);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->deauthReason);
+    CsrUint16Ser(ptr, len, (u16) primitive->disassocReason);
+    CsrUint16Ser(ptr, len, (u16) primitive->deauthReason);
     return(ptr);
 }
 
@@ -3452,89 +3452,89 @@ void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+    CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.authMode, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
     if (primitive->connectionInfo.beaconFrameLength)
     {
         primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
-        CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+        CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((u16) (primitive->connectionInfo.beaconFrameLength)));
     }
     else
     {
         primitive->connectionInfo.beaconFrame = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationReqFrameLength)
     {
         primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
-        CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+        CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationReqFrameLength)));
     }
     else
     {
         primitive->connectionInfo.associationReqFrame = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationRspFrameLength)
     {
         primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
-        CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+        CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((u16) (primitive->connectionInfo.associationRspFrameLength)));
     }
     else
     {
         primitive->connectionInfo.associationRspFrame = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocScanInfoElementsLength)
     {
         primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
-        CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+        CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocScanInfoElementsLength)));
     }
     else
     {
         primitive->connectionInfo.assocScanInfoElements = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
-    CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
+    CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((u16) (6)));
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocReqInfoElementsLength)
     {
         primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
-        CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+        CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocReqInfoElementsLength)));
     }
     else
     {
         primitive->connectionInfo.assocReqInfoElements = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocRspInfoElementsLength)
     {
         primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
-        CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+        CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((u16) (primitive->connectionInfo.assocRspInfoElementsLength)));
     }
     else
     {
         primitive->connectionInfo.assocRspInfoElements = NULL;
     }
-    CsrUint16Des((CsrUint16 *) &primitive->disassocReason, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->deauthReason, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->disassocReason, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->deauthReason, buffer, &offset);
 
     return primitive;
 }
@@ -3561,9 +3561,9 @@ CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg)
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrBool primitive->mibConfig.unifiFixMaxTxDataRate */
     bufferSize += 1; /* u8 primitive->mibConfig.unifiFixTxDataRate */
-    bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11RtsThreshold */
-    bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11FragmentationThreshold */
-    bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11CurrentTxPowerLevel */
+    bufferSize += 2; /* u16 primitive->mibConfig.dot11RtsThreshold */
+    bufferSize += 2; /* u16 primitive->mibConfig.dot11FragmentationThreshold */
+    bufferSize += 2; /* u16 primitive->mibConfig.dot11CurrentTxPowerLevel */
     return bufferSize;
 }
 
@@ -3573,12 +3573,12 @@ u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeMibConfigGetCfm *primitive = (CsrWifiSmeMibConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixMaxTxDataRate);
     CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixTxDataRate);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11RtsThreshold);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11FragmentationThreshold);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11CurrentTxPowerLevel);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11RtsThreshold);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11FragmentationThreshold);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibConfig.dot11CurrentTxPowerLevel);
     return(ptr);
 }
 
@@ -3590,12 +3590,12 @@ void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixTxDataRate, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
 
     return primitive;
 }
@@ -3608,7 +3608,7 @@ CsrSize CsrWifiSmeMibGetCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2;                             /* CsrResult primitive->status */
-    bufferSize += 2;                             /* CsrUint16 primitive->mibAttributeLength */
+    bufferSize += 2;                             /* u16 primitive->mibAttributeLength */
     bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
     return bufferSize;
 }
@@ -3619,11 +3619,11 @@ u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibAttributeLength);
     if (primitive->mibAttributeLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((u16) (primitive->mibAttributeLength)));
     }
     return(ptr);
 }
@@ -3636,12 +3636,12 @@ void* CsrWifiSmeMibGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibAttributeLength, buffer, &offset);
     if (primitive->mibAttributeLength)
     {
         primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
-        CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+        CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((u16) (primitive->mibAttributeLength)));
     }
     else
     {
@@ -3667,7 +3667,7 @@ CsrSize CsrWifiSmeMibGetNextCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2;                             /* CsrResult primitive->status */
-    bufferSize += 2;                             /* CsrUint16 primitive->mibAttributeLength */
+    bufferSize += 2;                             /* u16 primitive->mibAttributeLength */
     bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
     return bufferSize;
 }
@@ -3678,11 +3678,11 @@ u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->mibAttributeLength);
     if (primitive->mibAttributeLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((u16) (primitive->mibAttributeLength)));
     }
     return(ptr);
 }
@@ -3695,12 +3695,12 @@ void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->mibAttributeLength, buffer, &offset);
     if (primitive->mibAttributeLength)
     {
         primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
-        CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+        CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((u16) (primitive->mibAttributeLength)));
     }
     else
     {
@@ -3724,9 +3724,9 @@ CsrSize CsrWifiSmeMicFailureIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrBool primitive->secondFailure */
-    bufferSize += 2; /* CsrUint16 primitive->count */
+    bufferSize += 2; /* u16 primitive->count */
     bufferSize += 6; /* u8 primitive->address.a[6] */
     bufferSize += 1; /* CsrWifiSmeKeyType primitive->keyType */
     return bufferSize;
@@ -3738,10 +3738,10 @@ u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeMicFailureInd *primitive = (CsrWifiSmeMicFailureInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->secondFailure);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->count);
-    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->count);
+    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
     CsrUint8Ser(ptr, len, (u8) primitive->keyType);
     return(ptr);
 }
@@ -3754,10 +3754,10 @@ void* CsrWifiSmeMicFailureIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->secondFailure, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->count, buffer, &offset);
-    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->count, buffer, &offset);
+    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
     CsrUint8Des((u8 *) &primitive->keyType, buffer, &offset);
 
     return primitive;
@@ -3770,12 +3770,12 @@ CsrSize CsrWifiSmeMulticastAddressCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
     bufferSize += 1; /* u8 primitive->getAddressesCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
         {
             bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
@@ -3790,15 +3790,15 @@ u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint8Ser(ptr, len, (u8) primitive->getAddressesCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((u16) (6)));
         }
     }
     return(ptr);
@@ -3812,8 +3812,8 @@ void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->getAddressesCount, buffer, &offset);
     primitive->getAddresses = NULL;
@@ -3822,10 +3822,10 @@ void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, CsrSize length)
         primitive->getAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->getAddressesCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
         {
-            CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((u16) (6)));
         }
     }
 
@@ -3846,7 +3846,7 @@ CsrSize CsrWifiSmePacketFilterSetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -3857,8 +3857,8 @@ u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmePacketFilterSetCfm *primitive = (CsrWifiSmePacketFilterSetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -3870,8 +3870,8 @@ void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -3893,8 +3893,8 @@ u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmePermanentMacAddressGetCfm *primitive = (CsrWifiSmePermanentMacAddressGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrMemCpySer(ptr, len, (const void *) primitive->permanentMacAddress.a, ((CsrUint16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrMemCpySer(ptr, len, (const void *) primitive->permanentMacAddress.a, ((u16) (6)));
     return(ptr);
 }
 
@@ -3906,8 +3906,8 @@ void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrMemCpyDes(primitive->permanentMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrMemCpyDes(primitive->permanentMacAddress.a, buffer, &offset, ((u16) (6)));
 
     return primitive;
 }
@@ -3919,10 +3919,10 @@ CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* u8 primitive->pmkidCandidatesCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
         {
             bufferSize += 6; /* u8 primitive->pmkidCandidates[i1].bssid.a[6] */
@@ -3938,13 +3938,13 @@ u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->pmkidCandidatesCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->pmkidCandidates[i1].bssid.a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->pmkidCandidates[i1].bssid.a, ((u16) (6)));
             CsrUint8Ser(ptr, len, (u8) primitive->pmkidCandidates[i1].preAuthAllowed);
         }
     }
@@ -3959,7 +3959,7 @@ void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->pmkidCandidatesCount, buffer, &offset);
     primitive->pmkidCandidates = NULL;
     if (primitive->pmkidCandidatesCount)
@@ -3967,10 +3967,10 @@ void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, CsrSize length)
         primitive->pmkidCandidates = (CsrWifiSmePmkidCandidate *)CsrPmemAlloc(sizeof(CsrWifiSmePmkidCandidate) * primitive->pmkidCandidatesCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
         {
-            CsrMemCpyDes(primitive->pmkidCandidates[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->pmkidCandidates[i1].bssid.a, buffer, &offset, ((u16) (6)));
             CsrUint8Des((u8 *) &primitive->pmkidCandidates[i1].preAuthAllowed, buffer, &offset);
         }
     }
@@ -3993,12 +3993,12 @@ CsrSize CsrWifiSmePmkidCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 31) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
     bufferSize += 1; /* u8 primitive->getPmkidsCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
         {
             bufferSize += 6;  /* u8 primitive->getPmkids[i1].bssid.a[6] */
@@ -4014,16 +4014,16 @@ u8* CsrWifiSmePmkidCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint8Ser(ptr, len, (u8) primitive->getPmkidsCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->getPmkids[i1].bssid.a, ((CsrUint16) (6)));
-            CsrMemCpySer(ptr, len, (const void *) primitive->getPmkids[i1].pmkid, ((CsrUint16) (16)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->getPmkids[i1].bssid.a, ((u16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->getPmkids[i1].pmkid, ((u16) (16)));
         }
     }
     return(ptr);
@@ -4037,8 +4037,8 @@ void* CsrWifiSmePmkidCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->getPmkidsCount, buffer, &offset);
     primitive->getPmkids = NULL;
@@ -4047,11 +4047,11 @@ void* CsrWifiSmePmkidCfmDes(u8 *buffer, CsrSize length)
         primitive->getPmkids = (CsrWifiSmePmkid *)CsrPmemAlloc(sizeof(CsrWifiSmePmkid) * primitive->getPmkidsCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
         {
-            CsrMemCpyDes(primitive->getPmkids[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
-            CsrMemCpyDes(primitive->getPmkids[i1].pmkid, buffer, &offset, ((CsrUint16) (16)));
+            CsrMemCpyDes(primitive->getPmkids[i1].bssid.a, buffer, &offset, ((u16) (6)));
+            CsrMemCpyDes(primitive->getPmkids[i1].pmkid, buffer, &offset, ((u16) (16)));
         }
     }
 
@@ -4074,7 +4074,7 @@ CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSmePowerSaveLevel primitive->powerConfig.powerSaveLevel */
-    bufferSize += 2; /* CsrUint16 primitive->powerConfig.listenIntervalTu */
+    bufferSize += 2; /* u16 primitive->powerConfig.listenIntervalTu */
     bufferSize += 1; /* CsrBool primitive->powerConfig.rxDtims */
     bufferSize += 1; /* CsrWifiSmeD3AutoScanMode primitive->powerConfig.d3AutoScanMode */
     bufferSize += 1; /* u8 primitive->powerConfig.clientTrafficWindow */
@@ -4089,9 +4089,9 @@ u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmePowerConfigGetCfm *primitive = (CsrWifiSmePowerConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.powerSaveLevel);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->powerConfig.listenIntervalTu);
+    CsrUint16Ser(ptr, len, (u16) primitive->powerConfig.listenIntervalTu);
     CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.rxDtims);
     CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.d3AutoScanMode);
     CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.clientTrafficWindow);
@@ -4108,9 +4108,9 @@ void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
@@ -4140,11 +4140,11 @@ u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeRegulatoryDomainInfoGetCfm *primitive = (CsrWifiSmeRegulatoryDomainInfoGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->regDomInfo.dot11MultiDomainCapabilityImplemented);
     CsrUint8Ser(ptr, len, (u8) primitive->regDomInfo.dot11MultiDomainCapabilityEnabled);
     CsrUint8Ser(ptr, len, (u8) primitive->regDomInfo.currentRegulatoryDomain);
-    CsrMemCpySer(ptr, len, (const void *) primitive->regDomInfo.currentCountryCode, ((CsrUint16) (2)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->regDomInfo.currentCountryCode, ((u16) (2)));
     return(ptr);
 }
 
@@ -4156,11 +4156,11 @@ void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityImplemented, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityEnabled, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->regDomInfo.currentRegulatoryDomain, buffer, &offset);
-    CsrMemCpyDes(primitive->regDomInfo.currentCountryCode, buffer, &offset, ((CsrUint16) (2)));
+    CsrMemCpyDes(primitive->regDomInfo.currentCountryCode, buffer, &offset, ((u16) (2)));
 
     return primitive;
 }
@@ -4171,7 +4171,7 @@ CsrSize CsrWifiSmeRoamCompleteIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -4182,8 +4182,8 @@ u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeRoamCompleteInd *primitive = (CsrWifiSmeRoamCompleteInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -4195,8 +4195,8 @@ void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -4207,7 +4207,7 @@ CsrSize CsrWifiSmeRoamStartIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeRoamReason primitive->roamReason */
     bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->reason80211 */
     return bufferSize;
@@ -4219,9 +4219,9 @@ u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeRoamStartInd *primitive = (CsrWifiSmeRoamStartInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint8Ser(ptr, len, (u8) primitive->roamReason);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->reason80211);
+    CsrUint16Ser(ptr, len, (u16) primitive->reason80211);
     return(ptr);
 }
 
@@ -4233,9 +4233,9 @@ void* CsrWifiSmeRoamStartIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->roamReason, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->reason80211, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->reason80211, buffer, &offset);
 
     return primitive;
 }
@@ -4246,10 +4246,10 @@ CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 72) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
             bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].rssiHighThreshold */
@@ -4261,17 +4261,17 @@ CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg)
     bufferSize += 1;         /* CsrBool primitive->roamingConfig.disableSmoothRoaming */
     bufferSize += 1;         /* CsrBool primitive->roamingConfig.disableRoamScans */
     bufferSize += 1;         /* u8 primitive->roamingConfig.reconnectLimit */
-    bufferSize += 2;         /* CsrUint16 primitive->roamingConfig.reconnectLimitIntervalMs */
+    bufferSize += 2;         /* u16 primitive->roamingConfig.reconnectLimitIntervalMs */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].intervalSeconds */
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].validitySeconds */
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu */
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu */
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu */
-            bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].intervalSeconds */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].validitySeconds */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu */
+            bufferSize += 2; /* u16 primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu */
         }
     }
     return bufferSize;
@@ -4283,32 +4283,32 @@ u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeRoamingConfigGetCfm *primitive = (CsrWifiSmeRoamingConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiHighThreshold);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiLowThreshold);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrHighThreshold);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].rssiHighThreshold);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].rssiLowThreshold);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].snrHighThreshold);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
         }
     }
     CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableSmoothRoaming);
     CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableRoamScans);
     CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.reconnectLimit);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.reconnectLimitIntervalMs);
+    CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.reconnectLimitIntervalMs);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].intervalSeconds);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].validitySeconds);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].intervalSeconds);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].validitySeconds);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu);
         }
     }
     return(ptr);
@@ -4322,32 +4322,32 @@ void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiHighThreshold, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiLowThreshold, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrHighThreshold, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].rssiHighThreshold, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].rssiLowThreshold, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].snrHighThreshold, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
         }
     }
     CsrUint8Des((u8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->roamingConfig.reconnectLimit, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 3; i2++)
         {
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].intervalSeconds, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].validitySeconds, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].intervalSeconds, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].validitySeconds, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
         }
     }
 
@@ -4360,7 +4360,7 @@ CsrSize CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -4371,8 +4371,8 @@ u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeRoamingConfigSetCfm *primitive = (CsrWifiSmeRoamingConfigSetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -4384,8 +4384,8 @@ void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -4399,26 +4399,26 @@ CsrSize CsrWifiSmeScanConfigGetCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 65) */
     bufferSize += 2; /* CsrResult primitive->status */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].intervalSeconds */
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].validitySeconds */
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu */
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu */
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu */
-            bufferSize += 2;                                     /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].intervalSeconds */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].validitySeconds */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu */
+            bufferSize += 2;                                     /* u16 primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu */
         }
     }
     bufferSize += 1;                                             /* CsrBool primitive->scanConfig.disableAutonomousScans */
-    bufferSize += 2;                                             /* CsrUint16 primitive->scanConfig.maxResults */
+    bufferSize += 2;                                             /* u16 primitive->scanConfig.maxResults */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.highRssiThreshold */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.lowRssiThreshold */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.deltaRssiThreshold */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.highSnrThreshold */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.lowSnrThreshold */
     bufferSize += 1;                                             /* s8 primitive->scanConfig.deltaSnrThreshold */
-    bufferSize += 2;                                             /* CsrUint16 primitive->scanConfig.passiveChannelListCount */
+    bufferSize += 2;                                             /* u16 primitive->scanConfig.passiveChannelListCount */
     bufferSize += primitive->scanConfig.passiveChannelListCount; /* u8 primitive->scanConfig.passiveChannelList */
     return bufferSize;
 }
@@ -4429,31 +4429,31 @@ u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].intervalSeconds);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].validitySeconds);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].intervalSeconds);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].validitySeconds);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
         }
     }
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.disableAutonomousScans);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.maxResults);
+    CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.maxResults);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highRssiThreshold);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowRssiThreshold);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaRssiThreshold);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highSnrThreshold);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowSnrThreshold);
     CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaSnrThreshold);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.passiveChannelListCount);
+    CsrUint16Ser(ptr, len, (u16) primitive->scanConfig.passiveChannelListCount);
     if (primitive->scanConfig.passiveChannelListCount)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->scanConfig.passiveChannelList, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->scanConfig.passiveChannelList, ((u16) (primitive->scanConfig.passiveChannelListCount)));
     }
     return(ptr);
 }
@@ -4466,32 +4466,32 @@ void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].intervalSeconds, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].validitySeconds, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].intervalSeconds, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].validitySeconds, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
         }
     }
     CsrUint8Des((u8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->scanConfig.maxResults, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->scanConfig.maxResults, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->scanConfig.deltaSnrThreshold, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
     if (primitive->scanConfig.passiveChannelListCount)
     {
         primitive->scanConfig.passiveChannelList = (u8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
-        CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+        CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((u16) (primitive->scanConfig.passiveChannelListCount)));
     }
     else
     {
@@ -4522,15 +4522,15 @@ CsrSize CsrWifiSmeScanResultIndSizeof(void *msg)
     bufferSize += 2;                                           /* CsrInt16 primitive->result.rssi */
     bufferSize += 2;                                           /* CsrInt16 primitive->result.snr */
     bufferSize += 1;                                           /* CsrWifiSmeRadioIF primitive->result.ifIndex */
-    bufferSize += 2;                                           /* CsrUint16 primitive->result.beaconPeriodTu */
+    bufferSize += 2;                                           /* u16 primitive->result.beaconPeriodTu */
     bufferSize += 8;                                           /* u8 primitive->result.timeStamp.data[8] */
     bufferSize += 8;                                           /* u8 primitive->result.localTime.data[8] */
-    bufferSize += 2;                                           /* CsrUint16 primitive->result.channelFrequency */
-    bufferSize += 2;                                           /* CsrUint16 primitive->result.capabilityInformation */
+    bufferSize += 2;                                           /* u16 primitive->result.channelFrequency */
+    bufferSize += 2;                                           /* u16 primitive->result.capabilityInformation */
     bufferSize += 1;                                           /* u8 primitive->result.channelNumber */
     bufferSize += 1;                                           /* CsrWifiSmeBasicUsability primitive->result.usability */
     bufferSize += 1;                                           /* CsrWifiSmeBssType primitive->result.bssType */
-    bufferSize += 2;                                           /* CsrUint16 primitive->result.informationElementsLength */
+    bufferSize += 2;                                           /* u16 primitive->result.informationElementsLength */
     bufferSize += primitive->result.informationElementsLength; /* u8 primitive->result.informationElements */
     bufferSize += 1;                                           /* CsrWifiSmeP2pRole primitive->result.p2pDeviceRole */
     switch (primitive->result.p2pDeviceRole)
@@ -4543,7 +4543,7 @@ CsrSize CsrWifiSmeScanResultIndSizeof(void *msg)
             bufferSize += 6; /* u8 primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
             bufferSize += 1; /* u8 primitive->result.deviceInfo.groupInfo.p2pClientInfoCount */
             {
-                CsrUint16 i4;
+                u16 i4;
                 for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                 {
                     bufferSize += 6; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
@@ -4553,7 +4553,7 @@ CsrSize CsrWifiSmeScanResultIndSizeof(void *msg)
                     bufferSize += 8; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
                     bufferSize += 1; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
                     {
-                        CsrUint16 i6;
+                        u16 i6;
                         for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
                         {
                             bufferSize += 8; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
@@ -4574,7 +4574,7 @@ CsrSize CsrWifiSmeScanResultIndSizeof(void *msg)
             bufferSize += 8; /* u8 primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
             bufferSize += 1; /* u8 primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
             {
-                CsrUint16 i4;
+                u16 i4;
                 for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
                 {
                     bufferSize += 8; /* u8 primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
@@ -4595,24 +4595,24 @@ u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrMemCpySer(ptr, len, (const void *) primitive->result.ssid.ssid, ((CsrUint16) (32)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->result.ssid.ssid, ((u16) (32)));
     CsrUint8Ser(ptr, len, (u8) primitive->result.ssid.length);
-    CsrMemCpySer(ptr, len, (const void *) primitive->result.bssid.a, ((CsrUint16) (6)));
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.rssi);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.snr);
+    CsrMemCpySer(ptr, len, (const void *) primitive->result.bssid.a, ((u16) (6)));
+    CsrUint16Ser(ptr, len, (u16) primitive->result.rssi);
+    CsrUint16Ser(ptr, len, (u16) primitive->result.snr);
     CsrUint8Ser(ptr, len, (u8) primitive->result.ifIndex);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.beaconPeriodTu);
-    CsrMemCpySer(ptr, len, (const void *) primitive->result.timeStamp.data, ((CsrUint16) (8)));
-    CsrMemCpySer(ptr, len, (const void *) primitive->result.localTime.data, ((CsrUint16) (8)));
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.channelFrequency);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.capabilityInformation);
+    CsrUint16Ser(ptr, len, (u16) primitive->result.beaconPeriodTu);
+    CsrMemCpySer(ptr, len, (const void *) primitive->result.timeStamp.data, ((u16) (8)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->result.localTime.data, ((u16) (8)));
+    CsrUint16Ser(ptr, len, (u16) primitive->result.channelFrequency);
+    CsrUint16Ser(ptr, len, (u16) primitive->result.capabilityInformation);
     CsrUint8Ser(ptr, len, (u8) primitive->result.channelNumber);
     CsrUint8Ser(ptr, len, (u8) primitive->result.usability);
     CsrUint8Ser(ptr, len, (u8) primitive->result.bssType);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.informationElementsLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->result.informationElementsLength);
     if (primitive->result.informationElementsLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->result.informationElements, ((CsrUint16) (primitive->result.informationElementsLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->result.informationElements, ((u16) (primitive->result.informationElementsLength)));
     }
     CsrUint8Ser(ptr, len, (u8) primitive->result.p2pDeviceRole);
     switch (primitive->result.p2pDeviceRole)
@@ -4622,26 +4622,26 @@ u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg)
             break;
         case CSR_WIFI_SME_P2P_ROLE_GO:
             CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.groupCapability);
-            CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, ((u16) (6)));
             CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2pClientInfoCount);
             {
-                CsrUint16 i4;
+                u16 i4;
                 for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                 {
-                    CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((CsrUint16) (6)));
-                    CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((CsrUint16) (6)));
-                    CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
+                    CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((u16) (6)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((u16) (6)));
+                    CsrUint16Ser(ptr, len, (u16) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
                     CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
-                    CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((u16) (8)));
                     CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
                     {
-                        CsrUint16 i6;
+                        u16 i6;
                         for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
                         {
-                            CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, ((CsrUint16) (8)));
+                            CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, ((u16) (8)));
                         }
                     }
-                    CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((CsrUint16) (32)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((u16) (32)));
                     CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
                 }
             }
@@ -4650,19 +4650,19 @@ u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg)
             CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.reservedNone.empty);
             break;
         case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
-            CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, ((CsrUint16) (6)));
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.deviceInfo.standalonedevInfo.configMethods);
+            CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, ((u16) (6)));
+            CsrUint16Ser(ptr, len, (u16) primitive->result.deviceInfo.standalonedevInfo.configMethods);
             CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap);
-            CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((u16) (8)));
             CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
             {
-                CsrUint16 i4;
+                u16 i4;
                 for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
                 {
-                    CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, ((CsrUint16) (8)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, ((u16) (8)));
                 }
             }
-            CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceName, ((CsrUint16) (32)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceName, ((u16) (32)));
             CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.deviceNameLength);
             break;
         default:
@@ -4679,25 +4679,25 @@ void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrMemCpyDes(primitive->result.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+    CsrMemCpyDes(primitive->result.ssid.ssid, buffer, &offset, ((u16) (32)));
     CsrUint8Des((u8 *) &primitive->result.ssid.length, buffer, &offset);
-    CsrMemCpyDes(primitive->result.bssid.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint16Des((CsrUint16 *) &primitive->result.rssi, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->result.snr, buffer, &offset);
+    CsrMemCpyDes(primitive->result.bssid.a, buffer, &offset, ((u16) (6)));
+    CsrUint16Des((u16 *) &primitive->result.rssi, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->result.snr, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->result.ifIndex, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->result.beaconPeriodTu, buffer, &offset);
-    CsrMemCpyDes(primitive->result.timeStamp.data, buffer, &offset, ((CsrUint16) (8)));
-    CsrMemCpyDes(primitive->result.localTime.data, buffer, &offset, ((CsrUint16) (8)));
-    CsrUint16Des((CsrUint16 *) &primitive->result.channelFrequency, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->result.capabilityInformation, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->result.beaconPeriodTu, buffer, &offset);
+    CsrMemCpyDes(primitive->result.timeStamp.data, buffer, &offset, ((u16) (8)));
+    CsrMemCpyDes(primitive->result.localTime.data, buffer, &offset, ((u16) (8)));
+    CsrUint16Des((u16 *) &primitive->result.channelFrequency, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->result.capabilityInformation, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->result.channelNumber, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->result.usability, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->result.bssType, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->result.informationElementsLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->result.informationElementsLength, buffer, &offset);
     if (primitive->result.informationElementsLength)
     {
         primitive->result.informationElements = (u8 *)CsrPmemAlloc(primitive->result.informationElementsLength);
-        CsrMemCpyDes(primitive->result.informationElements, buffer, &offset, ((CsrUint16) (primitive->result.informationElementsLength)));
+        CsrMemCpyDes(primitive->result.informationElements, buffer, &offset, ((u16) (primitive->result.informationElementsLength)));
     }
     else
     {
@@ -4711,7 +4711,7 @@ void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize length)
             break;
         case CSR_WIFI_SME_P2P_ROLE_GO:
             CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.groupCapability, buffer, &offset);
-            CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((u16) (6)));
             CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
             primitive->result.deviceInfo.groupInfo.p2PClientInfo = NULL;
             if (primitive->result.deviceInfo.groupInfo.p2pClientInfoCount)
@@ -4719,14 +4719,14 @@ void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize length)
                 primitive->result.deviceInfo.groupInfo.p2PClientInfo = (CsrWifiSmeP2pClientInfoType *)CsrPmemAlloc(sizeof(CsrWifiSmeP2pClientInfoType) * primitive->result.deviceInfo.groupInfo.p2pClientInfoCount);
             }
             {
-                CsrUint16 i4;
+                u16 i4;
                 for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                 {
-                    CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((CsrUint16) (6)));
-                    CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
-                    CsrUint16Des((CsrUint16 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
+                    CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((u16) (6)));
+                    CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((u16) (6)));
+                    CsrUint16Des((u16 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
                     CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, buffer, &offset);
-                    CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+                    CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((u16) (8)));
                     CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
                     primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = NULL;
                     if (primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount)
@@ -4734,13 +4734,13 @@ void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize length)
                         primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
                     }
                     {
-                        CsrUint16 i6;
+                        u16 i6;
                         for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
                         {
-                            CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+                            CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, buffer, &offset, ((u16) (8)));
                         }
                     }
-                    CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+                    CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((u16) (32)));
                     CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
                 }
             }
@@ -4749,10 +4749,10 @@ void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize length)
             CsrUint8Des((u8 *) &primitive->result.deviceInfo.reservedNone.empty, buffer, &offset);
             break;
         case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
-            CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
-            CsrUint16Des((CsrUint16 *) &primitive->result.deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
+            CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((u16) (6)));
+            CsrUint16Des((u16 *) &primitive->result.deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
-            CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+            CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((u16) (8)));
             CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
             primitive->result.deviceInfo.standalonedevInfo.secDeviceType = NULL;
             if (primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount)
@@ -4760,13 +4760,13 @@ void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize length)
                 primitive->result.deviceInfo.standalonedevInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
             }
             {
-                CsrUint16 i4;
+                u16 i4;
                 for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
                 {
-                    CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+                    CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, buffer, &offset, ((u16) (8)));
                 }
             }
-            CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+            CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((u16) (32)));
             CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
             break;
         default:
@@ -4785,7 +4785,7 @@ void CsrWifiSmeScanResultIndSerFree(void *voidPrimitivePointer)
     {
         case CSR_WIFI_SME_P2P_ROLE_GO:
         {
-            CsrUint16 i4;
+            u16 i4;
             for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
             {
                 CsrPmemFree(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
@@ -4810,9 +4810,9 @@ CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 153) */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 2; /* CsrUint16 primitive->scanResultsCount */
+    bufferSize += 2; /* u16 primitive->scanResultsCount */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
         {
             bufferSize += 32;                                                   /* u8 primitive->scanResults[i1].ssid.ssid[32] */
@@ -4821,15 +4821,15 @@ CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
             bufferSize += 2;                                                    /* CsrInt16 primitive->scanResults[i1].rssi */
             bufferSize += 2;                                                    /* CsrInt16 primitive->scanResults[i1].snr */
             bufferSize += 1;                                                    /* CsrWifiSmeRadioIF primitive->scanResults[i1].ifIndex */
-            bufferSize += 2;                                                    /* CsrUint16 primitive->scanResults[i1].beaconPeriodTu */
+            bufferSize += 2;                                                    /* u16 primitive->scanResults[i1].beaconPeriodTu */
             bufferSize += 8;                                                    /* u8 primitive->scanResults[i1].timeStamp.data[8] */
             bufferSize += 8;                                                    /* u8 primitive->scanResults[i1].localTime.data[8] */
-            bufferSize += 2;                                                    /* CsrUint16 primitive->scanResults[i1].channelFrequency */
-            bufferSize += 2;                                                    /* CsrUint16 primitive->scanResults[i1].capabilityInformation */
+            bufferSize += 2;                                                    /* u16 primitive->scanResults[i1].channelFrequency */
+            bufferSize += 2;                                                    /* u16 primitive->scanResults[i1].capabilityInformation */
             bufferSize += 1;                                                    /* u8 primitive->scanResults[i1].channelNumber */
             bufferSize += 1;                                                    /* CsrWifiSmeBasicUsability primitive->scanResults[i1].usability */
             bufferSize += 1;                                                    /* CsrWifiSmeBssType primitive->scanResults[i1].bssType */
-            bufferSize += 2;                                                    /* CsrUint16 primitive->scanResults[i1].informationElementsLength */
+            bufferSize += 2;                                                    /* u16 primitive->scanResults[i1].informationElementsLength */
             bufferSize += primitive->scanResults[i1].informationElementsLength; /* u8 primitive->scanResults[i1].informationElements */
             bufferSize += 1;                                                    /* CsrWifiSmeP2pRole primitive->scanResults[i1].p2pDeviceRole */
             switch (primitive->scanResults[i1].p2pDeviceRole)
@@ -4842,7 +4842,7 @@ CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
                     bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
                     bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount */
                     {
-                        CsrUint16 i4;
+                        u16 i4;
                         for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                         {
                             bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
@@ -4852,7 +4852,7 @@ CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
                             bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
                             bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
                             {
-                                CsrUint16 i6;
+                                u16 i6;
                                 for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
                                 {
                                     bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
@@ -4873,7 +4873,7 @@ CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
                     bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
                     bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
                     {
-                        CsrUint16 i4;
+                        u16 i4;
                         for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
                         {
                             bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
@@ -4896,30 +4896,30 @@ u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResultsCount);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->scanResultsCount);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].ssid.ssid, ((CsrUint16) (32)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].ssid.ssid, ((u16) (32)));
             CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].ssid.length);
-            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].bssid.a, ((CsrUint16) (6)));
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].rssi);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].snr);
+            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].bssid.a, ((u16) (6)));
+            CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].rssi);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].snr);
             CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].ifIndex);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].beaconPeriodTu);
-            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].timeStamp.data, ((CsrUint16) (8)));
-            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].localTime.data, ((CsrUint16) (8)));
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].channelFrequency);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].capabilityInformation);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].beaconPeriodTu);
+            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].timeStamp.data, ((u16) (8)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].localTime.data, ((u16) (8)));
+            CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].channelFrequency);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].capabilityInformation);
             CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].channelNumber);
             CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].usability);
             CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].bssType);
-            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].informationElementsLength);
+            CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].informationElementsLength);
             if (primitive->scanResults[i1].informationElementsLength)
             {
-                CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].informationElements, ((CsrUint16) (primitive->scanResults[i1].informationElementsLength)));
+                CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].informationElements, ((u16) (primitive->scanResults[i1].informationElementsLength)));
             }
             CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].p2pDeviceRole);
             switch (primitive->scanResults[i1].p2pDeviceRole)
@@ -4929,26 +4929,26 @@ u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_GO:
                     CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability);
-                    CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, ((CsrUint16) (6)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, ((u16) (6)));
                     CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount);
                     {
-                        CsrUint16 i4;
+                        u16 i4;
                         for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                         {
-                            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((CsrUint16) (6)));
-                            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((CsrUint16) (6)));
-                            CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
+                            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((u16) (6)));
+                            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((u16) (6)));
+                            CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
                             CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
-                            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+                            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((u16) (8)));
                             CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
                             {
-                                CsrUint16 i6;
+                                u16 i6;
                                 for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
                                 {
-                                    CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, ((CsrUint16) (8)));
+                                    CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, ((u16) (8)));
                                 }
                             }
-                            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((CsrUint16) (32)));
+                            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((u16) (32)));
                             CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
                         }
                     }
@@ -4957,19 +4957,19 @@ u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
                     CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.reservedNone.empty);
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
-                    CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, ((CsrUint16) (6)));
-                    CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods);
+                    CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, ((u16) (6)));
+                    CsrUint16Ser(ptr, len, (u16) primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods);
                     CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap);
-                    CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((u16) (8)));
                     CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
                     {
-                        CsrUint16 i4;
+                        u16 i4;
                         for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
                         {
-                            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, ((CsrUint16) (8)));
+                            CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, ((u16) (8)));
                         }
                     }
-                    CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, ((CsrUint16) (32)));
+                    CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, ((u16) (32)));
                     CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength);
                     break;
                 default:
@@ -4988,36 +4988,36 @@ void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->scanResultsCount, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->scanResultsCount, buffer, &offset);
     primitive->scanResults = NULL;
     if (primitive->scanResultsCount)
     {
         primitive->scanResults = (CsrWifiSmeScanResult *)CsrPmemAlloc(sizeof(CsrWifiSmeScanResult) * primitive->scanResultsCount);
     }
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
         {
-            CsrMemCpyDes(primitive->scanResults[i1].ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+            CsrMemCpyDes(primitive->scanResults[i1].ssid.ssid, buffer, &offset, ((u16) (32)));
             CsrUint8Des((u8 *) &primitive->scanResults[i1].ssid.length, buffer, &offset);
-            CsrMemCpyDes(primitive->scanResults[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
-            CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].rssi, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].snr, buffer, &offset);
+            CsrMemCpyDes(primitive->scanResults[i1].bssid.a, buffer, &offset, ((u16) (6)));
+            CsrUint16Des((u16 *) &primitive->scanResults[i1].rssi, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanResults[i1].snr, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->scanResults[i1].ifIndex, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].beaconPeriodTu, buffer, &offset);
-            CsrMemCpyDes(primitive->scanResults[i1].timeStamp.data, buffer, &offset, ((CsrUint16) (8)));
-            CsrMemCpyDes(primitive->scanResults[i1].localTime.data, buffer, &offset, ((CsrUint16) (8)));
-            CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].channelFrequency, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].capabilityInformation, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanResults[i1].beaconPeriodTu, buffer, &offset);
+            CsrMemCpyDes(primitive->scanResults[i1].timeStamp.data, buffer, &offset, ((u16) (8)));
+            CsrMemCpyDes(primitive->scanResults[i1].localTime.data, buffer, &offset, ((u16) (8)));
+            CsrUint16Des((u16 *) &primitive->scanResults[i1].channelFrequency, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanResults[i1].capabilityInformation, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->scanResults[i1].channelNumber, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->scanResults[i1].usability, buffer, &offset);
             CsrUint8Des((u8 *) &primitive->scanResults[i1].bssType, buffer, &offset);
-            CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].informationElementsLength, buffer, &offset);
+            CsrUint16Des((u16 *) &primitive->scanResults[i1].informationElementsLength, buffer, &offset);
             if (primitive->scanResults[i1].informationElementsLength)
             {
                 primitive->scanResults[i1].informationElements = (u8 *)CsrPmemAlloc(primitive->scanResults[i1].informationElementsLength);
-                CsrMemCpyDes(primitive->scanResults[i1].informationElements, buffer, &offset, ((CsrUint16) (primitive->scanResults[i1].informationElementsLength)));
+                CsrMemCpyDes(primitive->scanResults[i1].informationElements, buffer, &offset, ((u16) (primitive->scanResults[i1].informationElementsLength)));
             }
             else
             {
@@ -5031,7 +5031,7 @@ void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize length)
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_GO:
                     CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability, buffer, &offset);
-                    CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+                    CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((u16) (6)));
                     CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
                     primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo = NULL;
                     if (primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount)
@@ -5039,14 +5039,14 @@ void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize length)
                         primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo = (CsrWifiSmeP2pClientInfoType *)CsrPmemAlloc(sizeof(CsrWifiSmeP2pClientInfoType) * primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount);
                     }
                     {
-                        CsrUint16 i4;
+                        u16 i4;
                         for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                         {
-                            CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((CsrUint16) (6)));
-                            CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
-                            CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
+                            CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((u16) (6)));
+                            CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((u16) (6)));
+                            CsrUint16Des((u16 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
                             CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, buffer, &offset);
-                            CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+                            CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((u16) (8)));
                             CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
                             primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = NULL;
                             if (primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount)
@@ -5054,13 +5054,13 @@ void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize length)
                                 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
                             }
                             {
-                                CsrUint16 i6;
+                                u16 i6;
                                 for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
                                 {
-                                    CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+                                    CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, buffer, &offset, ((u16) (8)));
                                 }
                             }
-                            CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+                            CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((u16) (32)));
                             CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
                         }
                     }
@@ -5069,10 +5069,10 @@ void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize length)
                     CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.reservedNone.empty, buffer, &offset);
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
-                    CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
-                    CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
+                    CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((u16) (6)));
+                    CsrUint16Des((u16 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
                     CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
-                    CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+                    CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((u16) (8)));
                     CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
                     primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType = NULL;
                     if (primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount)
@@ -5080,13 +5080,13 @@ void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize length)
                         primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
                     }
                     {
-                        CsrUint16 i4;
+                        u16 i4;
                         for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
                         {
-                            CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+                            CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, buffer, &offset, ((u16) (8)));
                         }
                     }
-                    CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+                    CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((u16) (32)));
                     CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
                     break;
                 default:
@@ -5103,7 +5103,7 @@ void CsrWifiSmeScanResultsGetCfmSerFree(void *voidPrimitivePointer)
 {
     CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *) voidPrimitivePointer;
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
         {
             CsrPmemFree(primitive->scanResults[i1].informationElements);
@@ -5111,7 +5111,7 @@ void CsrWifiSmeScanResultsGetCfmSerFree(void *voidPrimitivePointer)
             {
                 case CSR_WIFI_SME_P2P_ROLE_GO:
                 {
-                    CsrUint16 i4;
+                    u16 i4;
                     for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                     {
                         CsrPmemFree(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
@@ -5137,7 +5137,7 @@ CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* u8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
     bufferSize += 1; /* u8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
@@ -5154,8 +5154,8 @@ u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeSmeStaConfigGetCfm *primitive = (CsrWifiSmeSmeStaConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
     CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
     CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.wmmModeMask);
@@ -5173,8 +5173,8 @@ void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
@@ -5191,7 +5191,7 @@ CsrSize CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
-    bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2; /* u16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
@@ -5202,8 +5202,8 @@ u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeSmeStaConfigSetCfm *primitive = (CsrWifiSmeSmeStaConfigSetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     return(ptr);
 }
 
@@ -5215,8 +5215,8 @@ void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
 
     return primitive;
 }
@@ -5229,7 +5229,7 @@ CsrSize CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
     bufferSize += 2; /* CsrResult primitive->status */
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 2; i1++)
         {
             bufferSize += 6; /* u8 primitive->stationMacAddress[i1].a[6] */
@@ -5244,12 +5244,12 @@ u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeStationMacAddressGetCfm *primitive = (CsrWifiSmeStationMacAddressGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 2; i1++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((CsrUint16) (6)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((u16) (6)));
         }
     }
     return(ptr);
@@ -5263,12 +5263,12 @@ void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     {
-        CsrUint16 i1;
+        u16 i1;
         for (i1 = 0; i1 < 2; i1++)
         {
-            CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((CsrUint16) (6)));
+            CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((u16) (6)));
         }
     }
 
@@ -5282,10 +5282,10 @@ CsrSize CsrWifiSmeTspecIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
-    bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                      /* u16 primitive->interfaceTag */
     bufferSize += 4;                      /* CsrUint32 primitive->transactionId */
     bufferSize += 1;                      /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
-    bufferSize += 2;                      /* CsrUint16 primitive->tspecLength */
+    bufferSize += 2;                      /* u16 primitive->tspecLength */
     bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
     return bufferSize;
 }
@@ -5296,13 +5296,13 @@ u8* CsrWifiSmeTspecIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
     CsrUint8Ser(ptr, len, (u8) primitive->tspecResultCode);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->tspecLength);
     if (primitive->tspecLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((CsrUint16) (primitive->tspecLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((u16) (primitive->tspecLength)));
     }
     return(ptr);
 }
@@ -5315,14 +5315,14 @@ void* CsrWifiSmeTspecIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->tspecResultCode, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->tspecLength, buffer, &offset);
     if (primitive->tspecLength)
     {
         primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
-        CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
+        CsrMemCpyDes(primitive->tspec, buffer, &offset, ((u16) (primitive->tspecLength)));
     }
     else
     {
@@ -5347,11 +5347,11 @@ CsrSize CsrWifiSmeTspecCfmSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
-    bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
+    bufferSize += 2;                      /* u16 primitive->interfaceTag */
     bufferSize += 2;                      /* CsrResult primitive->status */
     bufferSize += 4;                      /* CsrUint32 primitive->transactionId */
     bufferSize += 1;                      /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
-    bufferSize += 2;                      /* CsrUint16 primitive->tspecLength */
+    bufferSize += 2;                      /* u16 primitive->tspecLength */
     bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
     return bufferSize;
 }
@@ -5362,14 +5362,14 @@ u8* CsrWifiSmeTspecCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->interfaceTag);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
     CsrUint8Ser(ptr, len, (u8) primitive->tspecResultCode);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
+    CsrUint16Ser(ptr, len, (u16) primitive->tspecLength);
     if (primitive->tspecLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((CsrUint16) (primitive->tspecLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((u16) (primitive->tspecLength)));
     }
     return(ptr);
 }
@@ -5382,15 +5382,15 @@ void* CsrWifiSmeTspecCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->interfaceTag, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->tspecResultCode, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->tspecLength, buffer, &offset);
     if (primitive->tspecLength)
     {
         primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
-        CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
+        CsrMemCpyDes(primitive->tspec, buffer, &offset, ((u16) (primitive->tspecLength)));
     }
     else
     {
@@ -5434,7 +5434,7 @@ u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipId);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipVersion);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwareBuild);
@@ -5455,7 +5455,7 @@ void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->versions.chipId, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->versions.chipVersion, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->versions.firmwareBuild, buffer, &offset);
@@ -5488,7 +5488,7 @@ CsrSize CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg)
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsidsCount */
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
             bufferSize += 32; /* u8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
@@ -5504,13 +5504,13 @@ u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsidsCount);
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
-            CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((CsrUint16) (32)));
+            CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((u16) (32)));
             CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsids[i2].length);
         }
     }
@@ -5525,7 +5525,7 @@ void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
     primitive->cloakedSsids.cloakedSsids = NULL;
     if (primitive->cloakedSsids.cloakedSsidsCount)
@@ -5533,10 +5533,10 @@ void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, CsrSize length)
         primitive->cloakedSsids.cloakedSsids = (CsrWifiSsid *)CsrPmemAlloc(sizeof(CsrWifiSsid) * primitive->cloakedSsids.cloakedSsidsCount);
     }
     {
-        CsrUint16 i2;
+        u16 i2;
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
-            CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((CsrUint16) (32)));
+            CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((u16) (32)));
             CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
         }
     }
@@ -5568,7 +5568,7 @@ u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeWifiOnInd *primitive = (CsrWifiSmeWifiOnInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((u16) (6)));
     return(ptr);
 }
 
@@ -5580,7 +5580,7 @@ void* CsrWifiSmeWifiOnIndDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+    CsrMemCpyDes(primitive->address.a, buffer, &offset, ((u16) (6)));
 
     return primitive;
 }
@@ -5605,9 +5605,9 @@ u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeSmeCommonConfigGetCfm *primitive = (CsrWifiSmeSmeCommonConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
     CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.trustLevel);
-    CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((CsrUint16) (2)));
+    CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((u16) (2)));
     CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.firmwareDriverInterface);
     CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.enableStrictDraftN);
     return(ptr);
@@ -5621,9 +5621,9 @@ void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
-    CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((CsrUint16) (2)));
+    CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((u16) (2)));
     CsrUint8Des((u8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
     CsrUint8Des((u8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
 
@@ -5637,7 +5637,7 @@ CsrSize CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 2; /* CsrUint16 primitive->numInterfaces */
+    bufferSize += 2; /* u16 primitive->numInterfaces */
     bufferSize += 2; /* u8 primitive->capBitmap[2] */
     return bufferSize;
 }
@@ -5648,9 +5648,9 @@ u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
     CsrWifiSmeInterfaceCapabilityGetCfm *primitive = (CsrWifiSmeInterfaceCapabilityGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint16Ser(ptr, len, (CsrUint16) primitive->numInterfaces);
-    CsrMemCpySer(ptr, len, (const void *) primitive->capBitmap, ((CsrUint16) (2)));
+    CsrUint16Ser(ptr, len, (u16) primitive->status);
+    CsrUint16Ser(ptr, len, (u16) primitive->numInterfaces);
+    CsrMemCpySer(ptr, len, (const void *) primitive->capBitmap, ((u16) (2)));
     return(ptr);
 }
 
@@ -5662,9 +5662,9 @@ void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, CsrSize length)
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint16Des((CsrUint16 *) &primitive->numInterfaces, buffer, &offset);
-    CsrMemCpyDes(primitive->capBitmap, buffer, &offset, ((CsrUint16) (2)));
+    CsrUint16Des((u16 *) &primitive->status, buffer, &offset);
+    CsrUint16Des((u16 *) &primitive->numInterfaces, buffer, &offset);
+    CsrMemCpyDes(primitive->capBitmap, buffer, &offset, ((u16) (2)));
 
     return primitive;
 }
@@ -5774,7 +5774,7 @@ u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, CsrSize *len, void *msg)
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
     if (primitive->dataLength)
     {
-        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpySer(ptr, len, (const void *) primitive->data, ((u16) (primitive->dataLength)));
     }
     return(ptr);
 }
@@ -5791,7 +5791,7 @@ void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, CsrSize length)
     if (primitive->dataLength)
     {
         primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
-        CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+        CsrMemCpyDes(primitive->data, buffer, &offset, ((u16) (primitive->dataLength)));
     }
     else
     {
diff --git a/drivers/staging/csr/csr_wifi_vif_utils.h b/drivers/staging/csr/csr_wifi_vif_utils.h
index ee8b438bbba..4eafbecf630 100644
--- a/drivers/staging/csr/csr_wifi_vif_utils.h
+++ b/drivers/staging/csr/csr_wifi_vif_utils.h
@@ -25,7 +25,7 @@ extern "C" {
 
 /* Common macros for NME and SME to be used temporarily until SoftMAC changes are made */
 #define CSR_WIFI_NUM_INTERFACES        (u8)0x1
-#define CSR_WIFI_INTERFACE_IN_USE      (CsrUint16)0x0
+#define CSR_WIFI_INTERFACE_IN_USE      (u16)0x0
 
 /* This is used at places where interface Id isn't available*/
 #define CSR_WIFI_INTERFACE_ZERO        0
@@ -37,14 +37,14 @@ extern "C" {
 
 /* Extract the Interface Id from the event */
 #define CsrWifiVifUtilsGetVifTagFromEvent(msg) \
-    ((CsrUint16) * ((CsrUint16 *) ((u8 *) (msg) + sizeof(CsrWifiFsmEvent))))
+    ((u16) * ((u16 *) ((u8 *) (msg) + sizeof(CsrWifiFsmEvent))))
 
 /* The HPI Vif combines the type and the interface id */
 #define CsrWifiVifUtilsGetVifTagFromHipEvent(msg) \
     ((msg)->virtualInterfaceIdentifier & 0x00FF)
 
 #define CsrWifiVifUtilsPackHipEventVif(type, interfaceId) \
-    ((CsrUint16)((interfaceId) | ((type) << 8)))
+    ((u16)((interfaceId) | ((type) << 8)))
 
 
 /* TYPES DEFINITIONS ********************************************************/
@@ -60,7 +60,7 @@ extern "C" {
  *
  * @param[in] u8 : interface capability bitmap
  * @param[in] u8* : pointer to the array of current interface modes
- * @param[in] CsrUint16 : interfaceTag
+ * @param[in] u16 : interfaceTag
  * @param[in] CsrWifiInterfaceMode : mode
  *
  * @return
@@ -68,7 +68,7 @@ extern "C" {
  */
 extern CsrBool CsrWifiVifUtilsCheckCompatibility(u8             interfaceCapability,
                                                  u8            *currentInterfaceModes,
-                                                 CsrUint16            interfaceTag,
+                                                 u16            interfaceTag,
                                                  CsrWifiInterfaceMode mode);
 
 /**
@@ -77,12 +77,12 @@ extern CsrBool CsrWifiVifUtilsCheckCompatibility(u8             interfaceCapabil
  *     NOTE: Only checks that the interface is supported, no checks are made to
  *     determine whether a supported interface may be made active.
  *
- * @param[in] CsrUint16 : interfaceTag
+ * @param[in] u16 : interfaceTag
  *
  * @return
  *     CsrBool : returns true if the interface is supported, otherwise false.
  */
-extern CsrBool CsrWifiVifUtilsIsSupported(CsrUint16 interfaceTag);
+extern CsrBool CsrWifiVifUtilsIsSupported(u16 interfaceTag);
 
 #ifdef CSR_LOG_ENABLE
 /**
diff --git a/drivers/staging/csr/data_tx.c b/drivers/staging/csr/data_tx.c
index c5858a58f3c..8ed7a7845cc 100644
--- a/drivers/staging/csr/data_tx.c
+++ b/drivers/staging/csr/data_tx.c
@@ -19,7 +19,7 @@ int
 uf_verify_m4(unifi_priv_t *priv, const unsigned char *packet, unsigned int length)
 {
     const unsigned char *p = packet;
-    CsrUint16 keyinfo;
+    u16 keyinfo;
 
 
     if (length < (4 + 5 + 8 + 32 + 16 + 8 + 8 + 16 + 1 + 8)) {
diff --git a/drivers/staging/csr/drv.c b/drivers/staging/csr/drv.c
index 4be6d9533cd..5ce33296fe4 100644
--- a/drivers/staging/csr/drv.c
+++ b/drivers/staging/csr/drv.c
@@ -1295,7 +1295,7 @@ unifi_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
       case UNIFI_INIT_NETDEV:
         {
             /* get the proper interfaceTagId */
-            CsrUint16 interfaceTag=0;
+            u16 interfaceTag=0;
             netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
 
             dev = priv->netdev[interfaceTag];
@@ -1483,14 +1483,14 @@ unifi_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 break;
             }
 
-            pcli->snap_filter.protocols = CsrPmemAlloc(snap_filter.count * sizeof(CsrUint16));
+            pcli->snap_filter.protocols = CsrPmemAlloc(snap_filter.count * sizeof(u16));
             if (!pcli->snap_filter.protocols) {
                 r = -ENOMEM;
                 goto out;
             }
             if (copy_from_user((void*)pcli->snap_filter.protocols,
                                (void*)snap_filter.protocols,
-                               snap_filter.count * sizeof(CsrUint16)))
+                               snap_filter.count * sizeof(u16)))
             {
                 CsrPmemFree(pcli->snap_filter.protocols);
                 r = -EFAULT;
@@ -1805,16 +1805,16 @@ udi_log_event(ul_client_t *pcli,
         {
             int timestamp = jiffies_to_msecs(jiffies);
             unifi_debug_log_to_buf("T:");
-            unifi_debug_log_to_buf("%04X%04X ", *(((CsrUint16*)&timestamp) + 1),
-                                   *(CsrUint16*)&timestamp);
+            unifi_debug_log_to_buf("%04X%04X ", *(((u16*)&timestamp) + 1),
+                                   *(u16*)&timestamp);
         }
 
         /* Add signal */
         unifi_debug_log_to_buf("S%s:%04X R:%04X D:%04X ",
                                dir ? "T" : "F",
-                               *(CsrUint16*)signal,
-                               *(CsrUint16*)(signal + 2),
-                               *(CsrUint16*)(signal + 4));
+                               *(u16*)signal,
+                               *(u16*)(signal + 2),
+                               *(u16*)(signal + 4));
         unifi_debug_hex_to_buf(signal + 6, signal_len - 6);
 
         /* Add bulk data (assume 1 bulk data per signal) */
diff --git a/drivers/staging/csr/io.c b/drivers/staging/csr/io.c
index f489ade7f1b..d0895797f62 100644
--- a/drivers/staging/csr/io.c
+++ b/drivers/staging/csr/io.c
@@ -333,7 +333,7 @@ register_unifi_sdio(CsrSdioFunction *sdio_dev, int bus_id, struct device *dev)
     Unifi_netdev_instances[bus_id * CSR_WIFI_NUM_INTERFACES] = netdev_priv(priv->netdev[0]);
 
     /* Initialise the mini-coredump capture buffers */
-    csrResult = unifi_coredump_init(priv->card, (CsrUint16)coredump_max);
+    csrResult = unifi_coredump_init(priv->card, (u16)coredump_max);
     if (csrResult != CSR_RESULT_SUCCESS) {
         unifi_error(priv, "Couldn't allocate mini-coredump buffers\n");
     }
diff --git a/drivers/staging/csr/netdev.c b/drivers/staging/csr/netdev.c
index cef0ba367bd..947a6ec2d61 100644
--- a/drivers/staging/csr/netdev.c
+++ b/drivers/staging/csr/netdev.c
@@ -553,7 +553,7 @@ uf_alloc_netdevice(CsrSdioFunction *sdio_dev, int bus_id)
  * ---------------------------------------------------------------------------
  */
 CsrBool
-uf_alloc_netdevice_for_other_interfaces(unifi_priv_t *priv, CsrUint16 interfaceTag)
+uf_alloc_netdevice_for_other_interfaces(unifi_priv_t *priv, u16 interfaceTag)
 {
     struct net_device *dev;
     netInterface_priv_t *interfacePriv;
@@ -1080,7 +1080,7 @@ skb_add_llc_snap(struct net_device *dev, struct sk_buff *skb, int proto)
 #ifdef CSR_SUPPORT_SME
 static int
 _identify_sme_ma_pkt_ind(unifi_priv_t *priv,
-                         const s8 *oui, CsrUint16 protocol,
+                         const s8 *oui, u16 protocol,
                          const CSR_SIGNAL *signal,
                          bulk_data_param_t *bulkdata,
                          const unsigned char *daddr,
@@ -1322,7 +1322,7 @@ skb_80211_to_ether(unifi_priv_t *priv, struct sk_buff *skb,
 } /* skb_80211_to_ether() */
 
 
-static CsrWifiRouterCtrlPortAction verify_port(unifi_priv_t *priv, unsigned char *address, int queue, CsrUint16 interfaceTag)
+static CsrWifiRouterCtrlPortAction verify_port(unifi_priv_t *priv, unsigned char *address, int queue, u16 interfaceTag)
 {
 #ifdef CSR_NATIVE_LINUX
 #ifdef CSR_SUPPORT_WEXT
@@ -1368,12 +1368,12 @@ static CsrWifiRouterCtrlPortAction verify_port(unifi_priv_t *priv, unsigned char
 int prepare_and_add_macheader(unifi_priv_t *priv, struct sk_buff *skb, struct sk_buff *newSkb,
                               CSR_PRIORITY priority,
                               bulk_data_param_t *bulkdata,
-                              CsrUint16 interfaceTag,
+                              u16 interfaceTag,
                               const u8 *daddr,
                               const u8 *saddr,
                               CsrBool protection)
 {
-    CsrUint16 fc = 0;
+    u16 fc = 0;
     u8 qc = 0;
     u8 macHeaderLengthInBytes = MAC_HEADER_SIZE, *bufPtr = NULL;
     bulk_data_param_t data_ptrs;
@@ -1649,12 +1649,12 @@ static int
 send_ma_pkt_request(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr *ehdr, CSR_PRIORITY priority)
 {
     int r;
-    CsrUint16 i;
+    u16 i;
     CsrBool eapolStore = FALSE;
     struct sk_buff *newSkb = NULL;
     bulk_data_param_t bulkdata;
     const int proto = ntohs(ehdr->h_proto);
-    CsrUint16 interfaceTag;
+    u16 interfaceTag;
     CsrWifiMacAddress peerAddress;
     CSR_TRANSMISSION_CONTROL transmissionControl = CSR_NO_CONFIRM_REQUIRED;
     s8 protection;
@@ -2150,7 +2150,7 @@ unifi_restart_xmit(void *ospriv, unifi_TrafficQueue queue)
 
 
 static void
-indicate_rx_skb(unifi_priv_t *priv, CsrUint16 ifTag, u8* dst_a, u8* src_a, struct sk_buff *skb, CSR_SIGNAL *signal,
+indicate_rx_skb(unifi_priv_t *priv, u16 ifTag, u8* dst_a, u8* src_a, struct sk_buff *skb, CSR_SIGNAL *signal,
                 bulk_data_param_t *bulkdata)
 {
     int r, sr = 0;
@@ -2250,7 +2250,7 @@ indicate_rx_skb(unifi_priv_t *priv, CsrUint16 ifTag, u8* dst_a, u8* src_a, struc
 void
 uf_process_rx_pending_queue(unifi_priv_t *priv, int queue,
                             CsrWifiMacAddress source_address,
-                            int indicate, CsrUint16 interfaceTag)
+                            int indicate, u16 interfaceTag)
 {
     rx_buffered_packets_t *rx_q_item;
     struct list_head *rx_list;
@@ -2325,7 +2325,7 @@ uf_process_rx_pending_queue(unifi_priv_t *priv, int queue,
 void
 uf_resume_data_plane(unifi_priv_t *priv, int queue,
                      CsrWifiMacAddress peer_address,
-                     CsrUint16 interfaceTag)
+                     u16 interfaceTag)
 {
 #ifdef CSR_SUPPORT_WEXT
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
@@ -2363,7 +2363,7 @@ uf_resume_data_plane(unifi_priv_t *priv, int queue,
 } /* uf_resume_data_plane() */
 
 
-void uf_free_pending_rx_packets(unifi_priv_t *priv, int queue, CsrWifiMacAddress peer_address,CsrUint16 interfaceTag)
+void uf_free_pending_rx_packets(unifi_priv_t *priv, int queue, CsrWifiMacAddress peer_address,u16 interfaceTag)
 {
     uf_process_rx_pending_queue(priv, queue, peer_address, 0,interfaceTag);
 
@@ -2387,7 +2387,7 @@ void uf_free_pending_rx_packets(unifi_priv_t *priv, int queue, CsrWifiMacAddress
 static void
 unifi_rx(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
 {
-    CsrUint16 interfaceTag;
+    u16 interfaceTag;
     bulk_data_desc_t *pData;
     const CSR_MA_PACKET_INDICATION *pkt_ind = &signal->u.MaPacketIndication;
     struct sk_buff *skb;
@@ -2398,7 +2398,7 @@ unifi_rx(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
 
     u8 da[ETH_ALEN], sa[ETH_ALEN];
     u8 toDs, fromDs, frameType, macHeaderLengthInBytes = MAC_HEADER_SIZE;
-    CsrUint16 frameControl;
+    u16 frameControl;
     netInterface_priv_t *interfacePriv;
     struct ethhdr ehdr;
 
@@ -2676,7 +2676,7 @@ unifi_rx(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
 
 static void process_ma_packet_cfm(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
 {
-    CsrUint16 interfaceTag;
+    u16 interfaceTag;
     const CSR_MA_PACKET_CONFIRM *pkt_cfm = &signal->u.MaPacketConfirm;
     netInterface_priv_t *interfacePriv;
 
@@ -2732,11 +2732,11 @@ static void process_ma_packet_cfm(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_d
  */
 static void process_ma_packet_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
 {
-    CsrUint16 interfaceTag;
+    u16 interfaceTag;
     bulk_data_desc_t *pData;
     CSR_MA_PACKET_INDICATION *pkt_ind = (CSR_MA_PACKET_INDICATION*)&signal->u.MaPacketIndication;
     struct sk_buff *skb;
-    CsrUint16 frameControl;
+    u16 frameControl;
     netInterface_priv_t *interfacePriv;
     u8 da[ETH_ALEN], sa[ETH_ALEN];
     u8 *bssid = NULL, *ba_addr = NULL;
@@ -2748,7 +2748,7 @@ static void process_ma_packet_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_d
     CsrBool powerSaveChanged = FALSE;
     u8 pmBit = 0;
     CsrWifiRouterCtrlStaInfo_t *srcStaInfo = NULL;
-    CsrUint16 qosControl;
+    u16 qosControl;
 
 #endif
 
@@ -2820,7 +2820,7 @@ static void process_ma_packet_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_d
     frameType = ((frameControl & 0x000C) >> 2);
 
     unifi_trace(priv, UDBG3, "Rx Frame Type: %d sn: %d\n",frameType,
-         (le16_to_cpu(*((CsrUint16*)(bulkdata->d[0].os_data_ptr + IEEE802_11_SEQUENCE_CONTROL_OFFSET))) >> 4) & 0xfff);
+         (le16_to_cpu(*((u16*)(bulkdata->d[0].os_data_ptr + IEEE802_11_SEQUENCE_CONTROL_OFFSET))) >> 4) & 0xfff);
     if(frameType == IEEE802_11_FRAMETYPE_CONTROL){
 #ifdef CSR_SUPPORT_SME
         unifi_trace(priv, UDBG6, "%s: Received Control Frame\n", __FUNCTION__);
@@ -2929,7 +2929,7 @@ static void process_ma_packet_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_d
                         frame_desc_struct frame_desc;
                         frame_desc.bulkdata = *bulkdata;
                         frame_desc.signal = *signal;
-                        frame_desc.sn = (le16_to_cpu(*((CsrUint16*)(bulkdata->d[0].os_data_ptr + IEEE802_11_SEQUENCE_CONTROL_OFFSET))) >> 4) & 0xfff;
+                        frame_desc.sn = (le16_to_cpu(*((u16*)(bulkdata->d[0].os_data_ptr + IEEE802_11_SEQUENCE_CONTROL_OFFSET))) >> 4) & 0xfff;
                         frame_desc.active = TRUE;
                         unifi_trace(priv, UDBG6, "%s: calling process_ba_frame (session=%d)\n", __FUNCTION__, ba_session_idx);
                         process_ba_frame(priv, interfacePriv, ba_session, &frame_desc);
@@ -3626,10 +3626,10 @@ static void
     bulk_data_param_t subframe_bulkdata;
     u8 *dot11_hdr_ptr = (u8*)bulkdata->d[0].os_data_ptr;
     CsrResult csrResult;
-    CsrUint16 frameControl;
+    u16 frameControl;
     u8 *qos_control_ptr;
 
-    frameControl = le16_to_cpu(*((CsrUint16*)dot11_hdr_ptr));
+    frameControl = le16_to_cpu(*((u16*)dot11_hdr_ptr));
     qos_control_ptr = dot11_hdr_ptr + (((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK))?30: 24);
     if(!(*qos_control_ptr & IEEE802_11_QC_A_MSDU_PRESENT)) {
         unifi_trace(priv, UDBG6, "%s: calling unifi_rx()", __FUNCTION__);
@@ -3712,10 +3712,10 @@ static void add_frame_to_ba_complete(unifi_priv_t *priv,
 static void update_expected_sn(unifi_priv_t *priv,
                           netInterface_priv_t *interfacePriv,
                           ba_session_rx_struct *ba_session,
-                          CsrUint16 sn)
+                          u16 sn)
 {
     int i, j;
-    CsrUint16 gap;
+    u16 gap;
 
     gap = (sn - ba_session->expected_sn) & 0xFFF;
     unifi_trace(priv, UDBG6, "%s: proccess the frames up to new_expected_sn = %d gap = %d\n", __FUNCTION__, sn, gap);
@@ -3754,7 +3754,7 @@ static void complete_ready_sequence(unifi_priv_t *priv,
 void scroll_ba_window(unifi_priv_t *priv,
                                 netInterface_priv_t *interfacePriv,
                                 ba_session_rx_struct *ba_session,
-                                CsrUint16 sn)
+                                u16 sn)
 {
     if(((sn - ba_session->expected_sn) & 0xFFF) <= 2048) {
         update_expected_sn(priv, interfacePriv, ba_session, sn);
@@ -3766,10 +3766,10 @@ void scroll_ba_window(unifi_priv_t *priv,
 static int consume_frame_or_get_buffer_index(unifi_priv_t *priv,
                                             netInterface_priv_t *interfacePriv,
                                             ba_session_rx_struct *ba_session,
-                                            CsrUint16 sn,
+                                            u16 sn,
                                             frame_desc_struct *frame_desc) {
     int i;
-    CsrUint16 sn_temp;
+    u16 sn_temp;
 
     if(((sn - ba_session->expected_sn) & 0xFFF) <= 2048) {
 
@@ -3781,7 +3781,7 @@ static int consume_frame_or_get_buffer_index(unifi_priv_t *priv,
         sn_temp = ba_session->expected_sn + ba_session->wind_size;
         unifi_trace(priv, UDBG6, "%s: new frame: sn=%d\n", __FUNCTION__, sn);
         if(!(((sn - sn_temp) & 0xFFF) > 2048)) {
-            CsrUint16 new_expected_sn;
+            u16 new_expected_sn;
             unifi_trace(priv, UDBG6, "%s: frame is out of window\n", __FUNCTION__);
             sn_temp = (sn - ba_session->wind_size) & 0xFFF;
             new_expected_sn = (sn_temp + 1) & 0xFFF;
@@ -3822,7 +3822,7 @@ static void process_ba_frame(unifi_priv_t *priv,
                                              frame_desc_struct *frame_desc)
 {
     int i;
-    CsrUint16 sn = frame_desc->sn;
+    u16 sn = frame_desc->sn;
 
     if (ba_session->timeout) {
         mod_timer(&ba_session->timer, (jiffies + usecs_to_jiffies((ba_session->timeout) * 1024)));
@@ -3868,7 +3868,7 @@ static void check_ba_frame_age_timeout( unifi_priv_t *priv,
     CsrTime now;
     CsrTime age;
     u8 i, j;
-    CsrUint16 sn_temp;
+    u16 sn_temp;
 
     /* gap is started at 1 because we have buffered frames and
      * hence a minimum gap of 1 exists
@@ -3941,7 +3941,7 @@ static void check_ba_frame_age_timeout( unifi_priv_t *priv,
 
 static void process_ma_packet_error_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
 {
-    CsrUint16 interfaceTag;
+    u16 interfaceTag;
     const CSR_MA_PACKET_ERROR_INDICATION *pkt_err_ind = &signal->u.MaPacketErrorIndication;
     netInterface_priv_t *interfacePriv;
     ba_session_rx_struct *ba_session;
diff --git a/drivers/staging/csr/os.c b/drivers/staging/csr/os.c
index f5a9352ce78..35dc9087d79 100644
--- a/drivers/staging/csr/os.c
+++ b/drivers/staging/csr/os.c
@@ -370,7 +370,7 @@ unifi_trace_nop(void* ospriv, int level, const char *fmt, ...)
 
 /* Memory dump with level filter controlled by unifi_debug */
 void
-unifi_dump(void *ospriv, int level, const char *msg, void *mem, CsrUint16 len)
+unifi_dump(void *ospriv, int level, const char *msg, void *mem, u16 len)
 {
     unifi_priv_t *priv = (unifi_priv_t*) ospriv;
 
@@ -400,7 +400,7 @@ unifi_dump(void *ospriv, int level, const char *msg, void *mem, CsrUint16 len)
 
 /* Memory dump that appears all the time, use sparingly */
 void
-dump(void *mem, CsrUint16 len)
+dump(void *mem, u16 len)
 {
     int i, col = 0;
     unsigned char *pdata = (unsigned char *)mem;
@@ -430,7 +430,7 @@ dump(void *mem, CsrUint16 len)
 
 
 void
-dump16(void *mem, CsrUint16 len)
+dump16(void *mem, u16 len)
 {
     int i, col=0;
     unsigned short *p = (unsigned short *)mem;
@@ -457,7 +457,7 @@ dump16(void *mem, CsrUint16 len)
 
 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
 void
-dump_str(void *mem, CsrUint16 len)
+dump_str(void *mem, u16 len)
 {
     int i, col = 0;
     unsigned char *pdata = (unsigned char *)mem;
diff --git a/drivers/staging/csr/putest.c b/drivers/staging/csr/putest.c
index 676c8f6bf6b..9c9dc60c900 100644
--- a/drivers/staging/csr/putest.c
+++ b/drivers/staging/csr/putest.c
@@ -545,7 +545,7 @@ free_fw:
 
 int unifi_putest_coredump_prepare(unifi_priv_t *priv, unsigned char *arg)
 {
-    CsrUint16 data_u16;
+    u16 data_u16;
     CsrInt32 i;
     CsrResult r;
 
diff --git a/drivers/staging/csr/sdio_mmc.c b/drivers/staging/csr/sdio_mmc.c
index f95a57f0072..8dc91bf920c 100644
--- a/drivers/staging/csr/sdio_mmc.c
+++ b/drivers/staging/csr/sdio_mmc.c
@@ -180,7 +180,7 @@ CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, u8 data)
 } /* CsrSdioWrite8() */
 
 CsrResult
-CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data)
+CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, u16 *data)
 {
     struct sdio_func *func = (struct sdio_func *)function->priv;
     int err;
@@ -207,7 +207,7 @@ CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data)
 
 
 CsrResult
-CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data)
+CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, u16 data)
 {
     struct sdio_func *func = (struct sdio_func *)function->priv;
     int err;
@@ -716,7 +716,7 @@ sdio_set_block_size_ignore_first_error(struct sdio_func *func, unsigned blksz)
 }
 
 CsrResult
-CsrSdioBlockSizeSet(CsrSdioFunction *function, CsrUint16 blockSize)
+CsrSdioBlockSizeSet(CsrSdioFunction *function, u16 blockSize)
 {
     struct sdio_func *func = (struct sdio_func *)function->priv;
     int r = 0;
diff --git a/drivers/staging/csr/sdio_stubs.c b/drivers/staging/csr/sdio_stubs.c
index bc6a3697c00..839fae01d96 100644
--- a/drivers/staging/csr/sdio_stubs.c
+++ b/drivers/staging/csr/sdio_stubs.c
@@ -38,7 +38,7 @@ CsrResult __attribute__((weak)) CsrSdioHardReset(CsrSdioFunction *function)
 }
 
 CsrResult __attribute__((weak)) CsrSdioBlockSizeSet(CsrSdioFunction *function,
-                                                   CsrUint16 blockSize)
+                                                   u16 blockSize)
 {
     return CSR_RESULT_SUCCESS;
 }
diff --git a/drivers/staging/csr/sme_blocking.c b/drivers/staging/csr/sme_blocking.c
index 8461baca2de..c95f1b30522 100644
--- a/drivers/staging/csr/sme_blocking.c
+++ b/drivers/staging/csr/sme_blocking.c
@@ -222,7 +222,7 @@ _sme_wait_for_reply(unifi_priv_t *priv,
 #ifdef CSR_SUPPORT_WEXT
 int sme_mgt_wifi_on(unifi_priv_t *priv)
 {
-    CsrUint16 numElements;
+    u16 numElements;
     CsrWifiSmeDataBlock* dataList;
 #ifdef CSR_SUPPORT_WEXT_AP
     int r;
@@ -350,7 +350,7 @@ int sme_mgt_scan_full(unifi_priv_t *priv,
                               is_active,
                               CSR_WIFI_SME_BSS_TYPE_ANY_BSS,
                               CSR_WIFI_SME_SCAN_TYPE_ALL,
-                              (CsrUint16)num_channels, channel_list,
+                              (u16)num_channels, channel_list,
                               0, NULL);
 
     r = sme_wait_for_reply(priv, UNIFI_SME_MGT_LONG_TIMEOUT);
@@ -372,7 +372,7 @@ int sme_mgt_scan_results_get_async(unifi_priv_t *priv,
         char *scan_results,
         long scan_results_len)
 {
-    CsrUint16 scan_result_list_count;
+    u16 scan_result_list_count;
     CsrWifiSmeScanResult *scan_result_list;
     CsrWifiSmeScanResult *scan_result;
     int r;
@@ -1443,7 +1443,7 @@ int sme_sys_resume(unifi_priv_t *priv)
 }
 
 #ifdef CSR_SUPPORT_WEXT_AP
-int sme_ap_stop(unifi_priv_t *priv,CsrUint16 interface_tag)
+int sme_ap_stop(unifi_priv_t *priv,u16 interface_tag)
 {
     int r;
 
@@ -1471,7 +1471,7 @@ int sme_ap_stop(unifi_priv_t *priv,CsrUint16 interface_tag)
 
 }
 
-int sme_ap_start(unifi_priv_t *priv,CsrUint16 interface_tag,
+int sme_ap_start(unifi_priv_t *priv,u16 interface_tag,
                  CsrWifiSmeApConfig_t * ap_config)
 {
     int r;
diff --git a/drivers/staging/csr/sme_native.c b/drivers/staging/csr/sme_native.c
index 2091109f7c1..2e63db2bc94 100644
--- a/drivers/staging/csr/sme_native.c
+++ b/drivers/staging/csr/sme_native.c
@@ -249,7 +249,7 @@ sme_native_log_event(ul_client_t *pcli,
     if (r == 0) {
         signal_len = SigGetSize(&signal);
     } else {
-        CsrUint16 receiver_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sig_packed) + sizeof(CsrUint16)) & 0xFF00;
+        u16 receiver_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sig_packed) + sizeof(u16)) & 0xFF00;
 
         /* The control indications are 1 byte, pass them to client. */
         if (sig_len == 1) {
diff --git a/drivers/staging/csr/sme_sys.c b/drivers/staging/csr/sme_sys.c
index e28e7c8ce0c..c3d9c6a98c2 100644
--- a/drivers/staging/csr/sme_sys.c
+++ b/drivers/staging/csr/sme_sys.c
@@ -64,7 +64,7 @@ void send_auto_ma_packet_confirm(unifi_priv_t *priv,
 
     CSR_SIGNAL unpacked_signal;
     u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
-    CsrUint16 packed_siglen;
+    u16 packed_siglen;
 
 
     list_for_each_safe(listHead, placeHolder, buffered_frames_list)
@@ -279,7 +279,7 @@ void CsrWifiRouterCtrlHipReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
     void *dest;
     CsrResult csrResult;
     CSR_SIGNAL *signal;
-    CsrUint16 interfaceTag = 0;
+    u16 interfaceTag = 0;
     CSR_MA_PACKET_REQUEST *req;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
 
@@ -301,7 +301,7 @@ void CsrWifiRouterCtrlHipReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
     signal = (CSR_SIGNAL *)hipreq->mlmeCommand;
 
     unifi_trace(priv, UDBG4, "CsrWifiRouterCtrlHipReqHandler: 0x04%X ---->\n",
-                *((CsrUint16*)hipreq->mlmeCommand));
+                *((u16*)hipreq->mlmeCommand));
 
     /* Construct the signal. */
     signal_ptr = (u8*)hipreq->mlmeCommand;
@@ -348,7 +348,7 @@ void CsrWifiRouterCtrlHipReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
     }
 
     unifi_trace(priv, UDBG3, "SME SEND: Signal 0x%.4X \n",
-                *((CsrUint16*)signal_ptr));
+                *((u16*)signal_ptr));
     if (signal->SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_REQUEST_ID)
     {
         CSR_SIGNAL unpacked_signal;
@@ -387,7 +387,7 @@ void CsrWifiRouterCtrlHipReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
     if (r) {
         unifi_error(priv,
                     "CsrWifiRouterCtrlHipReqHandler: Failed to send signal (0x%.4X - %u)\n",
-                    *((CsrUint16*)signal_ptr), r);
+                    *((u16*)signal_ptr), r);
         CsrWifiRouterCtrlWifiOffIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,CSR_WIFI_SME_CONTROL_INDICATION_ERROR);
     }
 
@@ -396,7 +396,7 @@ void CsrWifiRouterCtrlHipReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
 
 #ifdef CSR_WIFI_SEND_GRATUITOUS_ARP
 static void
-uf_send_gratuitous_arp(unifi_priv_t *priv, CsrUint16 interfaceTag)
+uf_send_gratuitous_arp(unifi_priv_t *priv, u16 interfaceTag)
 {
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
     CSR_PRIORITY priority;
@@ -504,7 +504,7 @@ configure_data_port(unifi_priv_t *priv,
         CsrWifiRouterCtrlPortAction port_action,
         const CsrWifiMacAddress *macAddress,
         const int queue,
-        CsrUint16 interfaceTag)
+        u16 interfaceTag)
 {
     const u8 broadcast_mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
     unifi_port_config_t *port;
@@ -1354,7 +1354,7 @@ void CsrWifiRouterCtrlTrafficClassificationReqHandler(void* drvpriv, CsrWifiFsmE
 static int
 _sys_packet_req(unifi_priv_t *priv, const CSR_SIGNAL *signal,
         u8 subscriptionHandle,
-        CsrUint16 frameLength, u8 *frame,
+        u16 frameLength, u8 *frame,
         int proto)
 {
     int r;
@@ -1364,7 +1364,7 @@ _sys_packet_req(unifi_priv_t *priv, const CSR_SIGNAL *signal,
     struct sk_buff *skb, *newSkb = NULL;
     CsrWifiMacAddress peerMacAddress;
     CsrResult csrResult;
-    CsrUint16 interfaceTag = req.VirtualInterfaceIdentifier & 0xff;
+    u16 interfaceTag = req.VirtualInterfaceIdentifier & 0xff;
     CsrBool eapolStore = FALSE;
     s8 protection = 0;
     netInterface_priv_t *interfacePriv;
@@ -1498,12 +1498,12 @@ void CsrWifiRouterMaPacketReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
     unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
     CsrWifiRouterMaPacketReq* mareq = (CsrWifiRouterMaPacketReq*)msg;
     llc_snap_hdr_t *snap;
-    CsrUint16 snap_protocol;
+    u16 snap_protocol;
     CSR_SIGNAL signal;
     CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
     CsrWifiRouterCtrlPortAction controlPortaction;
     u8 *daddr, *saddr;
-    CsrUint16 interfaceTag = mareq->interfaceTag & 0x00ff;
+    u16 interfaceTag = mareq->interfaceTag & 0x00ff;
     int queue;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
 
@@ -1638,7 +1638,7 @@ void CsrWifiRouterCtrlM4TransmitReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
 }
 
 /* reset the station records when the mode is set as CSR_WIFI_ROUTER_CTRL_MODE_NONE */
-static void CsrWifiRouterCtrlResetStationRecordList(unifi_priv_t *priv, CsrUint16 interfaceTag)
+static void CsrWifiRouterCtrlResetStationRecordList(unifi_priv_t *priv, u16 interfaceTag)
 {
     u8 i,j;
     CsrWifiRouterCtrlStaInfo_t *staInfo=NULL;
@@ -1723,7 +1723,7 @@ static void CsrWifiRouterCtrlResetStationRecordList(unifi_priv_t *priv, CsrUint1
     }
 }
 
-void CsrWifiRouterCtrlInterfaceReset(unifi_priv_t *priv, CsrUint16 interfaceTag)
+void CsrWifiRouterCtrlInterfaceReset(unifi_priv_t *priv, u16 interfaceTag)
 {
     netInterface_priv_t *interfacePriv;
 
@@ -2409,7 +2409,7 @@ void uf_send_disconnected_ind_wq(struct work_struct *work)
 
     CsrWifiRouterCtrlStaInfo_t *staInfo = container_of(work, CsrWifiRouterCtrlStaInfo_t, send_disconnected_ind_task);
     unifi_priv_t *priv;
-    CsrUint16 interfaceTag;
+    u16 interfaceTag;
     struct list_head send_cfm_list;
     u8 j;
 
@@ -2611,9 +2611,9 @@ static void ba_session_terminate_timer_func(unsigned long data)
 
 
 CsrBool blockack_session_stop(unifi_priv_t *priv,
-                                     CsrUint16 interfaceTag,
+                                     u16 interfaceTag,
                                      CsrWifiRouterCtrlBlockAckRole role,
-                                     CsrUint16 tID,
+                                     u16 tID,
                                      CsrWifiMacAddress macAddress)
 {
     netInterface_priv_t *interfacePriv;
@@ -2731,12 +2731,12 @@ void CsrWifiRouterCtrlBlockAckDisableReqHandler(void* drvpriv, CsrWifiFsmEvent*
 
 
 CsrBool blockack_session_start(unifi_priv_t *priv,
-                               CsrUint16 interfaceTag,
-                               CsrUint16 tID,
-                               CsrUint16 timeout,
+                               u16 interfaceTag,
+                               u16 tID,
+                               u16 timeout,
                                CsrWifiRouterCtrlBlockAckRole role,
-                               CsrUint16 wind_size,
-                               CsrUint16 start_sn,
+                               u16 wind_size,
+                               u16 start_sn,
                                CsrWifiMacAddress macAddress
                               )
 {
diff --git a/drivers/staging/csr/sme_userspace.c b/drivers/staging/csr/sme_userspace.c
index fc2506e4a95..b4a00096140 100644
--- a/drivers/staging/csr/sme_userspace.c
+++ b/drivers/staging/csr/sme_userspace.c
@@ -223,7 +223,7 @@ unifi_ta_indicate_protocol(void *ospriv,
 
     if (CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_RX == direction)
     {
-        CsrUint16 interfaceTag = 0;
+        u16 interfaceTag = 0;
         CsrWifiRouterCtrlTrafficProtocolIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,
                 interfaceTag,
                 packet_type,
diff --git a/drivers/staging/csr/sme_wext.c b/drivers/staging/csr/sme_wext.c
index 64e2939efa0..51c19bb97b7 100644
--- a/drivers/staging/csr/sme_wext.c
+++ b/drivers/staging/csr/sme_wext.c
@@ -727,7 +727,7 @@ iwprivsapstop(struct net_device *dev, struct iw_request_info *info,
     netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
     unifi_priv_t *priv = interfacePriv->privPtr;
     int r;
-    CsrUint16 interface_tag = interfacePriv->InterfaceTag;
+    u16 interface_tag = interfacePriv->InterfaceTag;
 
     unifi_trace(priv, UDBG1, "iwprivsapstop\n" );
     r = sme_ap_stop(priv,interface_tag);
@@ -766,7 +766,7 @@ iwprivsstackstop(struct net_device *dev, struct iw_request_info *info,
     netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
     unifi_priv_t *priv = interfacePriv->privPtr;
     int r = 0;
-    CsrUint16 interface_tag = interfacePriv->InterfaceTag;
+    u16 interface_tag = interfacePriv->InterfaceTag;
 
     unifi_trace(priv, UDBG1, "iwprivsstackstop\n" );
 
diff --git a/drivers/staging/csr/ul_int.c b/drivers/staging/csr/ul_int.c
index 3135468ef36..325218fc246 100644
--- a/drivers/staging/csr/ul_int.c
+++ b/drivers/staging/csr/ul_int.c
@@ -418,7 +418,7 @@ ul_send_signal_unpacked(unifi_priv_t *priv, CSR_SIGNAL *sigptr,
                         bulk_data_param_t *bulkdata)
 {
     u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
-    CsrUint16 packed_siglen;
+    u16 packed_siglen;
     CsrResult csrResult;
     unsigned long lock_flags;
     int r;
diff --git a/drivers/staging/csr/unifi_clients.h b/drivers/staging/csr/unifi_clients.h
index ca105e56571..418cb4d92fc 100644
--- a/drivers/staging/csr/unifi_clients.h
+++ b/drivers/staging/csr/unifi_clients.h
@@ -98,7 +98,7 @@ struct ul_client {
     CSR_SIGNAL* reply_signal;
     bulk_data_t* reply_bulkdata[UNIFI_MAX_DATA_REFERENCES];
 
-    CsrUint16 signal_filter[SIG_FILTER_SIZE];
+    u16 signal_filter[SIG_FILTER_SIZE];
 
 
     /* ------------------------------------------------------------------- */
diff --git a/drivers/staging/csr/unifi_event.c b/drivers/staging/csr/unifi_event.c
index bbc1564bd2f..c2ef2ee2107 100644
--- a/drivers/staging/csr/unifi_event.c
+++ b/drivers/staging/csr/unifi_event.c
@@ -97,7 +97,7 @@ static CsrBool check_routing_pkt_data_ind(unifi_priv_t *priv,
         CsrBool *freeBulkData,
         netInterface_priv_t *interfacePriv)
 {
-    CsrUint16  frmCtrl, receptionStatus, frmCtrlSubType;
+    u16  frmCtrl, receptionStatus, frmCtrlSubType;
     u8 *macHdrLocation;
     u8 interfaceTag;
     CsrBool isDataFrame;
@@ -112,7 +112,7 @@ static CsrBool check_routing_pkt_data_ind(unifi_priv_t *priv,
     CsrBool isWapiUnicastPkt = FALSE;
 
 #ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
-    CsrUint16 qosControl;
+    u16 qosControl;
 #endif
 
     u8 llcSnapHeaderOffset = 0;
@@ -467,7 +467,7 @@ unifi_process_receive_event(void *ospriv,
                    #define CSR_MA_PACKET_INDICATION_RECEPTION_STATUS_OFFSET    sizeof(CSR_SIGNAL_PRIMITIVE_HEADER) + 22
                    netInterface_priv_t *interfacePriv;
                    u8 interfaceTag;
-                   CsrUint16 receptionStatus = CSR_RX_SUCCESS;
+                   u16 receptionStatus = CSR_RX_SUCCESS;
 
                    /* Pull out interface tag from virtual interface identifier */
                    interfaceTag = (CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + CSR_MA_PACKET_INDICATION_INTERFACETAG_OFFSET)) & 0xff;
@@ -489,7 +489,7 @@ unifi_process_receive_event(void *ospriv,
                        CSR_SIGNAL signal;
                        u8 *destAddr;
                        CsrResult res;
-                       CsrUint16 interfaceTag = 0;
+                       u16 interfaceTag = 0;
                        CsrBool isMcastPkt = TRUE;
 
                        unifi_trace(priv, UDBG6, "Received a WAPI data packet when the Unicast/Multicast filter is set\n");
diff --git a/drivers/staging/csr/unifi_os.h b/drivers/staging/csr/unifi_os.h
index 0a974945068..4e63a942f1a 100644
--- a/drivers/staging/csr/unifi_os.h
+++ b/drivers/staging/csr/unifi_os.h
@@ -90,11 +90,11 @@ extern int unifi_debug;
     } while (0)
 
 
-void unifi_dump(void *ospriv, int lvl, const char *msg, void *mem, CsrUint16 len);
-void dump(void *mem, CsrUint16 len);
-void dump16(void *mem, CsrUint16 len);
+void unifi_dump(void *ospriv, int lvl, const char *msg, void *mem, u16 len);
+void dump(void *mem, u16 len);
+void dump16(void *mem, u16 len);
 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
-void dump_str(void *mem, CsrUint16 len);
+void dump_str(void *mem, u16 len);
 #endif /* CSR_WIFI_HIP_DEBUG_OFFLINE */
 
 void unifi_error(void* ospriv, const char *fmt, ...);
@@ -113,11 +113,11 @@ void unifi_trace(void* ospriv, int level, const char *fmt, ...);
 
 #define ASSERT(cond)
 
-static inline void unifi_dump(void *ospriv, int lvl, const char *msg, void *mem, CsrUint16 len) {}
-static inline void dump(void *mem, CsrUint16 len) {}
-static inline void dump16(void *mem, CsrUint16 len) {}
+static inline void unifi_dump(void *ospriv, int lvl, const char *msg, void *mem, u16 len) {}
+static inline void dump(void *mem, u16 len) {}
+static inline void dump16(void *mem, u16 len) {}
 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
-static inline void dump_str(void *mem, CsrUint16 len) {}
+static inline void dump_str(void *mem, u16 len) {}
 #endif /* CSR_WIFI_HIP_DEBUG_OFFLINE */
 
 void unifi_error_nop(void* ospriv, const char *fmt, ...);
diff --git a/drivers/staging/csr/unifi_pdu_processing.c b/drivers/staging/csr/unifi_pdu_processing.c
index a007a59aef9..51ce5e40b0a 100644
--- a/drivers/staging/csr/unifi_pdu_processing.c
+++ b/drivers/staging/csr/unifi_pdu_processing.c
@@ -55,7 +55,7 @@ static void _update_buffered_pkt_params_after_alignment(unifi_priv_t *priv, bulk
 void
 unifi_frame_ma_packet_req(unifi_priv_t *priv, CSR_PRIORITY priority,
                           CSR_RATE TransmitRate, CSR_CLIENT_TAG hostTag,
-                          CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
+                          u16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
                           CSR_PROCESS_ID leSenderProcessId, u8 *peerMacAddress,
                           CSR_SIGNAL *signal)
 {
@@ -137,7 +137,7 @@ int frame_and_send_queued_pdu(unifi_priv_t* priv,tx_buffered_packets_t* buffered
     int result;
     u8 toDs, fromDs, macHeaderLengthInBytes = MAC_HEADER_SIZE;
     u8 *qc;
-    CsrUint16 *fc = (CsrUint16*)(buffered_pkt->bulkdata.os_data_ptr);
+    u16 *fc = (u16*)(buffered_pkt->bulkdata.os_data_ptr);
     unsigned long lock_flags;
     unifi_trace(priv, UDBG3, "frame_and_send_queued_pdu with moreData: %d , EOSP: %d\n",moreData,eosp);
     unifi_frame_ma_packet_req(priv, buffered_pkt->priority, buffered_pkt->rate, buffered_pkt->hostTag,
@@ -449,7 +449,7 @@ CsrResult enque_tx_data_pdu(unifi_priv_t *priv, bulk_data_param_t *bulkdata,
 
 #ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
 CsrResult unifi_reque_ma_packet_request (void *ospriv, CsrUint32 host_tag,
-                                         CsrUint16 txStatus, bulk_data_desc_t *bulkDataDesc)
+                                         u16 txStatus, bulk_data_desc_t *bulkDataDesc)
 {
     CsrResult status = CSR_RESULT_SUCCESS;
     unifi_priv_t *priv = (unifi_priv_t*)ospriv;
@@ -459,9 +459,9 @@ CsrResult unifi_reque_ma_packet_request (void *ospriv, CsrUint32 host_tag,
     bulk_data_param_t bulkData;
     CSR_SIGNAL signal;
     CSR_PRIORITY priority = 0;
-    CsrUint16 interfaceTag = 0;
+    u16 interfaceTag = 0;
     unifi_TrafficQueue priority_q;
-    CsrUint16 frameControl = 0, frameType = 0;
+    u16 frameControl = 0, frameType = 0;
     unsigned long lock_flags;
 
     interfacePriv = priv->interfacePriv[interfaceTag];
@@ -531,7 +531,7 @@ CsrResult unifi_reque_ma_packet_request (void *ospriv, CsrUint32 host_tag,
 
         /* Extract the Packet priority */
         if (TRUE == staRecord->wmmOrQosEnabled) {
-            CsrUint16 qosControl = 0;
+            u16 qosControl = 0;
             u8  dataFrameType = 0;
 
             dataFrameType =((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> 4);
@@ -635,15 +635,15 @@ static void is_all_ac_deliver_enabled_and_moredata(CsrWifiRouterCtrlStaInfo_t *s
  *
  * ---------------------------------------------------------------------------
  */
-void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, CsrUint16 receiverProcessId)
+void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, u16 receiverProcessId)
 {
     u8 handle = CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId);
     u8 timSetStatus = CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId);
-    CsrUint16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
+    u16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
     CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
     /* This variable holds what TIM value we wanted to set in firmware */
-    CsrUint16 timSetValue = 0;
+    u16 timSetValue = 0;
     /* Irrespective of interface the count maintained */
     static u8 retryCount = 0;
     unsigned long lock_flags;
@@ -859,7 +859,7 @@ void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, CsrUin
  *
  * ---------------------------------------------------------------------------
  */
-void update_tim(unifi_priv_t * priv, CsrUint16 aid, u8 setTim, CsrUint16 interfaceTag, CsrUint32 handle)
+void update_tim(unifi_priv_t * priv, u16 aid, u8 setTim, u16 interfaceTag, CsrUint32 handle)
 {
     CSR_SIGNAL signal;
     CsrInt32 r;
@@ -956,7 +956,7 @@ void update_tim(unifi_priv_t * priv, CsrUint16 aid, u8 setTim, CsrUint16 interfa
 static
 void process_peer_active_transition(unifi_priv_t * priv,
                                     CsrWifiRouterCtrlStaInfo_t *staRecord,
-                                    CsrUint16 interfaceTag)
+                                    u16 interfaceTag)
 {
     int r,i;
     CsrBool spaceAvail[4] = {TRUE,TRUE,TRUE,TRUE};
@@ -1072,7 +1072,7 @@ void process_peer_active_transition(unifi_priv_t * priv,
 
 
 
-void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,CsrUint16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm)
+void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,u16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm)
 {
     netInterface_priv_t *interfacePriv;
     u8 i;
@@ -1201,7 +1201,7 @@ void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,CsrUint16 interfaceTag, con
 }
 
 #endif
-CsrUint16 uf_get_vif_identifier (CsrWifiRouterCtrlMode mode, CsrUint16 tag)
+u16 uf_get_vif_identifier (CsrWifiRouterCtrlMode mode, u16 tag)
 {
     switch(mode)
     {
@@ -1255,12 +1255,12 @@ CsrUint16 uf_get_vif_identifier (CsrWifiRouterCtrlMode mode, CsrUint16 tag)
 
 static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
                             struct sk_buff *newSkb, CSR_PRIORITY *priority,
-                            bulk_data_param_t *bulkdata, CsrUint16 interfaceTag,
+                            bulk_data_param_t *bulkdata, u16 interfaceTag,
                             u8 macHeaderLengthInBytes,
                             u8 qosDestination)
 {
 
-    CsrUint16 *fc = NULL;
+    u16 *fc = NULL;
     u8 direction = 0, toDs, fromDs;
     u8 *bufPtr = NULL;
     u8 sa[ETH_ALEN], da[ETH_ALEN];
@@ -1280,7 +1280,7 @@ static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
     headroom = skb_headroom(skb);
 
     /*  pointer to frame control field */
-    fc = (CsrUint16*) macHeaderBuf;
+    fc = (u16*) macHeaderBuf;
 
     toDs = (*fc & cpu_to_le16(IEEE802_11_FC_TO_DS_MASK))?1 : 0;
     fromDs = (*fc & cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK))? 1: 0;
@@ -1510,7 +1510,7 @@ uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
                        u8 macHeaderLengthInBytes)
 {
     const CSR_MA_PACKET_INDICATION *ind = &(signal->u.MaPacketIndication);
-    CsrUint16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0x00ff);
+    u16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0x00ff);
     struct sk_buff *newSkb = NULL;
     /* pointer to skb or private skb created using skb_copy() */
     struct sk_buff *skbPtr = skb;
@@ -1645,7 +1645,7 @@ uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
 CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
                                    u8 *peerMacAddress,
                                    CSR_CLIENT_TAG hostTag,
-                                   CsrUint16 interfaceTag,
+                                   u16 interfaceTag,
                                    CSR_TRANSMISSION_CONTROL transmissionControl,
                                    CSR_RATE TransmitRate,
                                    CSR_PRIORITY priority,
@@ -1662,7 +1662,7 @@ CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
     int frameType = 0;
     CsrBool queuePacketDozing = FALSE;
     CsrUint32 priority_q;
-    CsrUint16 frmCtrl;
+    u16 frmCtrl;
     struct list_head * list = NULL; /* List to which buffered PDUs are to be enqueued*/
     CsrBool setBcTim=FALSE;
     netInterface_priv_t *interfacePriv;
@@ -1976,7 +1976,7 @@ CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
 }
 
 #ifdef CSR_SUPPORT_SME
-s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *daddr)
+s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, u16 interfaceTag, const u8 *daddr)
 {
     s8 protection = 0;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
@@ -2017,7 +2017,7 @@ s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interf
 }
 #endif
 #ifdef CSR_SUPPORT_SME
-u8 send_multicast_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
+u8 send_multicast_frames(unifi_priv_t *priv, u16 interfaceTag)
 {
     int r;
     tx_buffered_packets_t * buffered_pkt = NULL;
@@ -2122,7 +2122,7 @@ void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata,
     CSR_SIGNAL signal;
     CSR_MA_VIF_AVAILABILITY_INDICATION *ind;
     int r;
-    CsrUint16 interfaceTag;
+    u16 interfaceTag;
     u8 pduSent =0;
     CSR_RESULT_CODE resultCode = CSR_RC_SUCCESS;
     netInterface_priv_t *interfacePriv;
@@ -2130,7 +2130,7 @@ void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata,
     func_enter();
     unifi_trace(priv, UDBG3,
             "uf_process_ma_vif_availibility_ind: Process signal 0x%.4X\n",
-            *((CsrUint16*)sigdata));
+            *((u16*)sigdata));
 
     r = read_unpack_signal(sigdata, &signal);
     if (r) {
@@ -2265,7 +2265,7 @@ void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv,
                                             struct list_head *txList)
 {
 
-    CsrUint16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
+    u16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
     tx_buffered_packets_t * buffered_pkt = NULL;
     unsigned long lock_flags;
     CsrBool eosp=FALSE;
@@ -2408,7 +2408,7 @@ void uf_send_buffered_data_from_ac(unifi_priv_t *priv,
 
 void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue q)
 {
-    CsrUint16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
+    u16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
     CsrUint32 startIndex=0,endIndex=0;
     CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
     u8 queue;
@@ -2576,7 +2576,7 @@ CsrBool uf_is_more_data_for_non_delivery_ac(CsrWifiRouterCtrlStaInfo_t *staRecor
 }
 
 
-int uf_process_station_records_for_sending_data(unifi_priv_t *priv,CsrUint16 interfaceTag,
+int uf_process_station_records_for_sending_data(unifi_priv_t *priv,u16 interfaceTag,
                                                  CsrWifiRouterCtrlStaInfo_t *srcStaInfo,
                                                  CsrWifiRouterCtrlStaInfo_t *dstStaInfo)
 {
@@ -2636,7 +2636,7 @@ int uf_process_station_records_for_sending_data(unifi_priv_t *priv,CsrUint16 int
  *      interfaceTag    virtual interface tag
  * ---------------------------------------------------------------------------
  */
-static void uf_handle_uspframes_delivery(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t *staInfo, CsrUint16 interfaceTag)
+static void uf_handle_uspframes_delivery(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t *staInfo, u16 interfaceTag)
 {
 
     s8 i;
@@ -2733,8 +2733,8 @@ static void uf_handle_uspframes_delivery(unifi_priv_t * priv, CsrWifiRouterCtrlS
 
 void uf_process_wmm_deliver_ac_uapsd(unifi_priv_t * priv,
                                      CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
-                                     CsrUint16 qosControl,
-                                     CsrUint16 interfaceTag)
+                                     u16 qosControl,
+                                     u16 interfaceTag)
 {
     CSR_PRIORITY priority;
     unifi_TrafficQueue priority_q;
@@ -2759,7 +2759,7 @@ void uf_process_wmm_deliver_ac_uapsd(unifi_priv_t * priv,
 }
 
 
-void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
+void uf_send_qos_null(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
 {
     bulk_data_param_t bulkdata;
     CsrResult csrResult;
@@ -2830,7 +2830,7 @@ void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,C
     return;
 
 }
-void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
+void uf_send_nulldata(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
 {
     bulk_data_param_t bulkdata;
     CsrResult csrResult;
@@ -2958,7 +2958,7 @@ CsrBool uf_check_broadcast_bssid(unifi_priv_t *priv, const bulk_data_param_t *bu
 
 
 CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
-                                u8 pmBit,CsrUint16 interfaceTag)
+                                u8 pmBit,u16 interfaceTag)
 {
     CsrBool moreData = FALSE;
     CsrBool powerSaveChanged = FALSE;
@@ -3052,7 +3052,7 @@ CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo
 
 
 
-void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,CsrUint16 interfaceTag)
+void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,u16 interfaceTag)
 {
     CsrWifiRouterCtrlStaInfo_t *staRecord =
     CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, sa, interfaceTag);
@@ -3448,7 +3448,7 @@ tx_buffered_packets_t *dequeue_tx_data_pdu(unifi_priv_t *priv, struct list_head
 /* generic function to get the station record handler */
 CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(unifi_priv_t *priv,
         const u8 *peerMacAddress,
-        CsrUint16 interfaceTag)
+        u16 interfaceTag)
 {
     u8 i;
     netInterface_priv_t *interfacePriv;
@@ -3482,7 +3482,7 @@ CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(
 /* generic function to get the station record handler from the handle */
 CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_priv_t *priv,
                                                                  CsrUint32 handle,
-                                                                 CsrUint16 interfaceTag)
+                                                                 u16 interfaceTag)
 {
     netInterface_priv_t *interfacePriv;
 
@@ -3495,7 +3495,7 @@ CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_p
 }
 
 /* Function to do inactivity */
-void uf_check_inactivity(unifi_priv_t *priv, CsrUint16 interfaceTag, CsrTime currentTime)
+void uf_check_inactivity(unifi_priv_t *priv, u16 interfaceTag, CsrTime currentTime)
 {
     CsrUint32 i;
     CsrWifiRouterCtrlStaInfo_t *staInfo;
@@ -3544,7 +3544,7 @@ void uf_check_inactivity(unifi_priv_t *priv, CsrUint16 interfaceTag, CsrTime cur
 }
 
 /* Function to update activity of a station */
-void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *peerMacAddress)
+void uf_update_sta_activity(unifi_priv_t *priv, u16 interfaceTag, const u8 *peerMacAddress)
 {
     CsrTime elapsedTime, currentTime;    /* Time in microseconds */
     CsrTime timeHi;         /* Not used - Time in microseconds */
@@ -3587,7 +3587,7 @@ void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8
         uf_check_inactivity(priv, interfaceTag, currentTime);
     }
 }
-void resume_unicast_buffered_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
+void resume_unicast_buffered_frames(unifi_priv_t *priv, u16 interfaceTag)
 {
 
    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
@@ -3677,7 +3677,7 @@ void resume_unicast_buffered_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
     }
     func_exit();
 }
-void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,CsrUint16 interfaceTag)
+void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,u16 interfaceTag)
 {
 
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
@@ -3718,7 +3718,7 @@ void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,CsrUint16 int
  *      interfaceTag    For which resume should happen
  * ---------------------------------------------------------------------------
  */
-void resume_suspended_uapsd(unifi_priv_t* priv,CsrUint16 interfaceTag)
+void resume_suspended_uapsd(unifi_priv_t* priv,u16 interfaceTag)
 {
 
    u8 startIndex;
diff --git a/drivers/staging/csr/unifi_priv.h b/drivers/staging/csr/unifi_priv.h
index f56c7025380..126e7c694da 100644
--- a/drivers/staging/csr/unifi_priv.h
+++ b/drivers/staging/csr/unifi_priv.h
@@ -305,7 +305,7 @@ typedef u8 CsrWifiAcPowersaveMode;
 typedef struct tx_buffered_packets {
     /* List link structure */
     struct list_head q;
-    CsrUint16 interfaceTag;
+    u16 interfaceTag;
     CSR_CLIENT_TAG hostTag;
     CSR_PROCESS_ID leSenderProcessId;
     CSR_TRANSMISSION_CONTROL transmissionControl;
@@ -325,9 +325,9 @@ typedef struct CsrWifiRouterCtrlStaInfo_t {
     CsrUint32 assignedHandle;
     CsrBool wmmOrQosEnabled;
     CsrWifiAcPowersaveMode powersaveMode[MAX_ACCESS_CATOGORY];
-    CsrUint16 maxSpLength;
+    u16 maxSpLength;
     CsrBool uapsdActive;
-    CsrUint16 noOfSpFramesSent;
+    u16 noOfSpFramesSent;
 
     /* Router/Driver database */
 #ifdef CSR_SUPPORT_SME
@@ -338,7 +338,7 @@ typedef struct CsrWifiRouterCtrlStaInfo_t {
     struct netInterface_priv *interfacePriv;
     struct work_struct send_disconnected_ind_task;
     CsrBool activity_flag;
-    CsrUint16 listenIntervalInTus;
+    u16 listenIntervalInTus;
     CSR_CLIENT_TAG nullDataHostTag;
 
     /* Activity timestamps for the station */
@@ -355,7 +355,7 @@ typedef struct CsrWifiRouterCtrlStaInfo_t {
     u8 prevFrmType;
     u8 prevFrmAccessCatogory;
     CsrBool protection;
-    CsrUint16 aid;
+    u16 aid;
     CsrBool txSuspend;
     u8 timSet;
     /* Dont change the value of below macro for SET & RESET */
@@ -366,13 +366,13 @@ typedef struct CsrWifiRouterCtrlStaInfo_t {
 
     CsrBool timRequestPendingFlag;
     u8 updateTimReqQueued;
-    CsrUint16 noOfPktQueued;
+    u16 noOfPktQueued;
 }CsrWifiRouterCtrlStaInfo_t;
 
 #ifdef CSR_SUPPORT_WEXT_AP
 struct CsrWifiSmeApConfig {
     CsrWifiSsid ssid;
-    CsrUint16 channel;
+    u16 channel;
     CsrWifiNmeApCredentials credentials;
     u8 max_connections;
     u8 if_index;
@@ -387,7 +387,7 @@ typedef struct
 {
     u8 *bufptr; /* Signal Primitive */
     bulk_data_param_t data_ptrs; /* Bulk Data pointers */
-    CsrUint16 sig_len;
+    u16 sig_len;
 }rx_buff_struct_t;
 
 typedef struct
@@ -496,7 +496,7 @@ struct unifi_priv {
     u8 allPeerDozing;
     u8 pausedStaHandle[MAX_ACCESS_CATOGORY];
     /* Max packet the driver can queue, irrespective of interface number */
-    CsrUint16 noOfPktQueuedInDriver;
+    u16 noOfPktQueuedInDriver;
 #define CSR_WIFI_DRIVER_SUPPORT_FOR_MAX_PKT_QUEUEING 512
 #define CSR_WIFI_DRIVER_MAX_PKT_QUEUING_THRESHOLD_PER_PEER 64
 #define CSR_WIFI_DRIVER_MINIMUM_BROADCAST_PKT_THRESHOLD 3
@@ -674,7 +674,7 @@ struct unifi_priv {
 };
 
 typedef struct {
-    CsrUint16 queue_length[4];
+    u16 queue_length[4];
     u8 os_queue_paused;
 } unifi_OsQosInfo;
 
@@ -683,21 +683,21 @@ typedef struct {
     CsrBool active;
     bulk_data_param_t bulkdata;
     CSR_SIGNAL signal;
-    CsrUint16 sn;
+    u16 sn;
     CsrTime recv_time;
 } frame_desc_struct;
 
 typedef struct {
     frame_desc_struct *buffer;
-    CsrUint16 wind_size;
-    CsrUint16 occupied_slots;
+    u16 wind_size;
+    u16 occupied_slots;
     struct timer_list timer;
-    CsrUint16 timeout;
-    CsrUint16 expected_sn;
-    CsrUint16 start_sn;
+    u16 timeout;
+    u16 expected_sn;
+    u16 start_sn;
     CsrBool   trigger_ba_after_ssn;
     struct netInterface_priv *interfacePriv;
-    CsrUint16 tID;
+    u16 tID;
     CsrWifiMacAddress macAddress;
     struct work_struct send_ba_err_task;
 } ba_session_rx_struct;
@@ -705,13 +705,13 @@ typedef struct {
 
 typedef struct {
     struct netInterface_priv *interfacePriv;
-    CsrUint16 tID;
+    u16 tID;
     CsrWifiMacAddress macAddress;
 } ba_session_tx_struct;
 
 typedef struct netInterface_priv
 {
-    CsrUint16 InterfaceTag;
+    u16 InterfaceTag;
     struct unifi_priv *privPtr;
     ba_session_tx_struct *ba_session_tx[MAX_SUPPORTED_BA_SESSIONS_TX];
     ba_session_rx_struct *ba_session_rx[MAX_SUPPORTED_BA_SESSIONS_RX];
@@ -770,7 +770,7 @@ typedef struct netInterface_priv
     CsrTime last_inactivity_check;
 
     /*number of multicast or borad cast packets  queued*/
-    CsrUint16 noOfbroadcastPktQueued;
+    u16 noOfbroadcastPktQueued;
 #endif
     /* A list to hold the buffered uncontrolled port packets */
     struct list_head rx_uncontrolled_list;
@@ -895,7 +895,7 @@ unifi_priv_t *uf_alloc_netdevice(CsrSdioFunction *sdio_dev, int bus_id);
 int uf_free_netdevice(unifi_priv_t *priv);
 
 /* Allocating function for other interfaces */
-CsrBool uf_alloc_netdevice_for_other_interfaces(unifi_priv_t *priv, CsrUint16 interfaceTag);
+CsrBool uf_alloc_netdevice_for_other_interfaces(unifi_priv_t *priv, u16 interfaceTag);
 
 /*
  * Firmware download related functions.
@@ -957,8 +957,8 @@ int uf_verify_m4(unifi_priv_t *priv, const unsigned char *packet,
 
 #ifdef CSR_SUPPORT_SME
 CsrBool uf_check_broadcast_bssid(unifi_priv_t *priv, const bulk_data_param_t *bulkdata);
-CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,u8 pmBit,CsrUint16 interfaceTag);
-void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,CsrUint16 interfaceTag);
+CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,u8 pmBit,u16 interfaceTag);
+void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,u16 interfaceTag);
 int uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
                    struct ethhdr *ehdr, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
                    const CSR_SIGNAL *signal,
@@ -967,24 +967,24 @@ int uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
 CsrBool uf_is_more_data_for_non_delivery_ac(CsrWifiRouterCtrlStaInfo_t *staRecord);
 void uf_process_wmm_deliver_ac_uapsd (  unifi_priv_t * priv,
                                         CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
-                                        CsrUint16 qosControl,
-                                        CsrUint16 interfaceTag);
+                                        u16 qosControl,
+                                        u16 interfaceTag);
 
 void uf_send_buffered_data_from_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, u8 queue, struct list_head *txList);
 void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, u8 queue, struct list_head *txList);
 
 void uf_continue_uapsd(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo);
-void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
-void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
+void uf_send_qos_null(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
+void uf_send_nulldata(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
 
 
 
 #endif
-CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,  u8 *peerMacAddress, CSR_CLIENT_TAG hostTag, CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl, CSR_RATE TransmitRate, CSR_PRIORITY priority, CSR_PROCESS_ID senderId, bulk_data_param_t *bulkdata);
+CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,  u8 *peerMacAddress, CSR_CLIENT_TAG hostTag, u16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl, CSR_RATE TransmitRate, CSR_PRIORITY priority, CSR_PROCESS_ID senderId, bulk_data_param_t *bulkdata);
 void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata, CsrUint32 siglen);
 #ifdef CSR_SUPPORT_SME
 void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue queue);
-int uf_process_station_records_for_sending_data(unifi_priv_t *priv,CsrUint16 interfaceTag,
+int uf_process_station_records_for_sending_data(unifi_priv_t *priv,u16 interfaceTag,
                                                  CsrWifiRouterCtrlStaInfo_t *srcStaInfo,
                                                  CsrWifiRouterCtrlStaInfo_t *dstStaInfo);
 void uf_prepare_send_cfm_list_for_queued_pkts(unifi_priv_t * priv,
@@ -995,9 +995,9 @@ void send_auto_ma_packet_confirm(unifi_priv_t *priv,
                                  struct list_head *buffered_frames_list);
 void uf_flush_list(unifi_priv_t * priv, struct list_head * list);
 tx_buffered_packets_t *dequeue_tx_data_pdu(unifi_priv_t *priv, struct list_head *txList);
-void resume_unicast_buffered_frames(unifi_priv_t *priv, CsrUint16 interfaceTag);
-void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,CsrUint16 interfaceTag);
-void resume_suspended_uapsd(unifi_priv_t* priv,CsrUint16 interfaceTag);
+void resume_unicast_buffered_frames(unifi_priv_t *priv, u16 interfaceTag);
+void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,u16 interfaceTag);
+void resume_suspended_uapsd(unifi_priv_t* priv,u16 interfaceTag);
 #endif
 /*
  *      netdev.c
@@ -1028,7 +1028,7 @@ int prepare_and_add_macheader(unifi_priv_t *priv,
                               struct sk_buff *newSkb,
                               CSR_PRIORITY priority,
                               bulk_data_param_t *bulkdata,
-                              CsrUint16 interfaceTag,
+                              u16 interfaceTag,
                               const u8 *daddr,
                               const u8 *saddr,
                               CsrBool protection);
@@ -1038,7 +1038,7 @@ get_packet_priority(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr
 void
 unifi_frame_ma_packet_req(unifi_priv_t *priv, CSR_PRIORITY priority,
                           CSR_RATE TransmitRate, CSR_CLIENT_TAG hostTag,
-                          CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
+                          u16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
                           CSR_PROCESS_ID leSenderProcessId, u8 *peerMacAddress,
                           CSR_SIGNAL *signal);
 
@@ -1053,40 +1053,40 @@ unifi_frame_ma_packet_req(unifi_priv_t *priv, CSR_PRIORITY priority,
 /* handle is 6 bits to accomodate in senderId LSB (only 64 station can be associated) */
 #define CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE 0x3F
 
-void update_tim(unifi_priv_t * priv, CsrUint16 aid, u8 setTim, CsrUint16 interfaceTag, CsrUint32 handle);
-void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, CsrUint16 senderProcessId);
+void update_tim(unifi_priv_t * priv, u16 aid, u8 setTim, u16 interfaceTag, CsrUint32 handle);
+void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, u16 senderProcessId);
 
 /* Clear the Peer station Record, in case of wifioff/unexpected card removal */
-void CsrWifiRouterCtrlInterfaceReset(unifi_priv_t *priv, CsrUint16 interfaceTag);
+void CsrWifiRouterCtrlInterfaceReset(unifi_priv_t *priv, u16 interfaceTag);
 
 void scroll_ba_window(unifi_priv_t *priv,
                       netInterface_priv_t *interfacePriv,
                       ba_session_rx_struct *ba_session,
-                      CsrUint16 sn);
+                      u16 sn);
 
 CsrBool blockack_session_stop(unifi_priv_t *priv,
-                              CsrUint16 interfaceTag,
+                              u16 interfaceTag,
                               CsrWifiRouterCtrlBlockAckRole role,
-                              CsrUint16 tID,
+                              u16 tID,
                               CsrWifiMacAddress macAddress);
 #ifdef CSR_SUPPORT_SME
 /* Fetch the protection information from interface Mode */
-s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *daddr);
+s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, u16 interfaceTag, const u8 *daddr);
 #endif
 
 /* Fetch the station record handler from data base for matching Mac address */
 #ifdef CSR_SUPPORT_SME
 CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(unifi_priv_t *priv,
                                                                                 const u8 *peerMacAddress,
-                                                                                CsrUint16 interfaceTag);
+                                                                                u16 interfaceTag);
 
 /* Fetch the station record handler from data base for matching handle */
 CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_priv_t *priv,
                                                                  CsrUint32 handle,
-                                                                 CsrUint16 interfaceTag);
+                                                                 u16 interfaceTag);
 
-void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *peerMacAddress);
-void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,CsrUint16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm);
+void uf_update_sta_activity(unifi_priv_t *priv, u16 interfaceTag, const u8 *peerMacAddress);
+void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,u16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm);
 #endif
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 int uf_install_qdisc(struct net_device *dev);
@@ -1094,9 +1094,9 @@ int uf_install_qdisc(struct net_device *dev);
 
 void uf_resume_data_plane(unifi_priv_t *priv, int queue,
                           CsrWifiMacAddress peer_address,
-                          CsrUint16 interfaceTag);
+                          u16 interfaceTag);
 void uf_free_pending_rx_packets(unifi_priv_t *priv, int queue,
-        CsrWifiMacAddress peer_address,CsrUint16 interfaceTag);
+        CsrWifiMacAddress peer_address,u16 interfaceTag);
 
 int uf_register_netdev(unifi_priv_t *priv, int numOfInterface);
 void uf_unregister_netdev(unifi_priv_t *priv);
@@ -1104,11 +1104,11 @@ void uf_unregister_netdev(unifi_priv_t *priv);
 void uf_net_get_name(struct net_device *dev, char *name, int len);
 
 void uf_send_queue_info(unifi_priv_t *priv);
-CsrUint16 uf_get_vif_identifier(CsrWifiRouterCtrlMode mode, CsrUint16 tag);
+u16 uf_get_vif_identifier(CsrWifiRouterCtrlMode mode, u16 tag);
 
 void uf_process_rx_pending_queue(unifi_priv_t *priv, int queue,
                                  CsrWifiMacAddress source_address,
-                                 int indicate, CsrUint16 interfaceTag);
+                                 int indicate, u16 interfaceTag);
 
 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
 int uf_register_hip_offline_debug(unifi_priv_t *priv);
diff --git a/drivers/staging/csr/unifi_sme.c b/drivers/staging/csr/unifi_sme.c
index 559213ba8bc..98c9c07dadb 100644
--- a/drivers/staging/csr/unifi_sme.c
+++ b/drivers/staging/csr/unifi_sme.c
@@ -114,7 +114,7 @@ sme_log_event(ul_client_t *pcli,
         }
         if (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_INDICATION_ID)
         {
-            CsrUint16 frmCtrl;
+            u16 frmCtrl;
             CsrBool unicastPdu = TRUE;
             u8 *macHdrLocation;
             u8 *raddr = NULL, *taddr = NULL;
@@ -147,7 +147,7 @@ sme_log_event(ul_client_t *pcli,
                 if(ind->ReceptionStatus == CSR_RX_SUCCESS)
                 {
                     u8 pmBit = (frmCtrl & 0x1000)?0x01:0x00;
-                    CsrUint16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0xff);
+                    u16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0xff);
                     CsrWifiRouterCtrlStaInfo_t *srcStaInfo =  CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,taddr,interfaceTag);
                     if((srcStaInfo != NULL) && (uf_check_broadcast_bssid(priv, bulkdata)== FALSE))
                     {
@@ -163,7 +163,7 @@ sme_log_event(ul_client_t *pcli,
         if (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_CONFIRM_ID)
         {
             CSR_MA_PACKET_CONFIRM *cfm = &unpacked_signal.u.MaPacketConfirm;
-            CsrUint16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
+            u16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
             netInterface_priv_t *interfacePriv;
             CSR_MA_PACKET_REQUEST *req;
             CsrWifiMacAddress peerMacAddress;
@@ -212,7 +212,7 @@ sme_log_event(ul_client_t *pcli,
 #endif
                 /* If EAPOL was requested via router APIs then send cfm else ignore*/
                 if((cfm->HostTag & 0x80000000) != CSR_WIFI_EAPOL_M4_HOST_TAG) {
-                    CsrWifiRouterMaPacketCfmSend((CsrUint16)signal[2],
+                    CsrWifiRouterMaPacketCfmSend((u16)signal[2],
                         cfm->VirtualInterfaceIdentifier,
                         result,
                         (cfm->HostTag & 0x3fffffff), cfm->Rate);
@@ -268,7 +268,7 @@ sme_log_event(ul_client_t *pcli,
  * ---------------------------------------------------------------------------
  */
 CsrWifiRouterCtrlPortAction
-uf_sme_port_state(unifi_priv_t *priv, unsigned char *address, int queue, CsrUint16 interfaceTag)
+uf_sme_port_state(unifi_priv_t *priv, unsigned char *address, int queue, u16 interfaceTag)
 {
     int i;
     unifi_port_config_t *port;
@@ -332,7 +332,7 @@ uf_sme_port_state(unifi_priv_t *priv, unsigned char *address, int queue, CsrUint
  * ---------------------------------------------------------------------------
  */
 unifi_port_cfg_t*
-uf_sme_port_config_handle(unifi_priv_t *priv, unsigned char *address, int queue, CsrUint16 interfaceTag)
+uf_sme_port_config_handle(unifi_priv_t *priv, unsigned char *address, int queue, u16 interfaceTag)
 {
     int i;
     unifi_port_config_t *port;
@@ -387,7 +387,7 @@ uf_multicast_list_wq(struct work_struct *work)
     unifi_priv_t *priv = container_of(work, unifi_priv_t,
             multicast_list_task);
     int i;
-    CsrUint16 interfaceTag = 0;
+    u16 interfaceTag = 0;
     CsrWifiMacAddress* multicast_address_list = NULL;
     int mc_count;
     u8 *mc_list;
@@ -867,7 +867,7 @@ int unifi_cfg_get_info(unifi_priv_t *priv, unsigned char *arg)
             break;
         case UNIFI_CFG_GET_INSTANCE:
             {
-                CsrUint16 InterfaceId=0;
+                u16 InterfaceId=0;
                 uf_net_get_name(priv->netdev[InterfaceId], &inst_name[0], sizeof(inst_name));
 
                 /* Copy the info to the out buffer */
@@ -1054,7 +1054,7 @@ uf_ta_ind_wq(struct work_struct *work)
 {
     struct ta_ind *ind = container_of(work, struct ta_ind, task);
     unifi_priv_t *priv = container_of(ind, unifi_priv_t, ta_ind_work);
-    CsrUint16 interfaceTag = 0;
+    u16 interfaceTag = 0;
 
 
     CsrWifiRouterCtrlTrafficProtocolIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,
@@ -1091,7 +1091,7 @@ uf_ta_sample_ind_wq(struct work_struct *work)
 {
     struct ta_sample_ind *ind = container_of(work, struct ta_sample_ind, task);
     unifi_priv_t *priv = container_of(ind, unifi_priv_t, ta_sample_ind_work);
-    CsrUint16 interfaceTag = 0;
+    u16 interfaceTag = 0;
 
      unifi_trace(priv, UDBG5, "rxtcp %d txtcp %d rxudp %d txudp %d prio %d\n",
         priv->rxTcpThroughput,
@@ -1152,7 +1152,7 @@ void
 uf_send_m4_ready_wq(struct work_struct *work)
 {
     netInterface_priv_t *InterfacePriv = container_of(work, netInterface_priv_t, send_m4_ready_task);
-    CsrUint16 iface = InterfacePriv->InterfaceTag;
+    u16 iface = InterfacePriv->InterfaceTag;
     unifi_priv_t *priv = InterfacePriv->privPtr;
     CSR_MA_PACKET_REQUEST *req = &InterfacePriv->m4_signal.u.MaPacketRequest;
     CsrWifiMacAddress peer;
@@ -1195,7 +1195,7 @@ uf_send_m4_ready_wq(struct work_struct *work)
 void uf_send_pkt_to_encrypt(struct work_struct *work)
 {
     netInterface_priv_t *interfacePriv = container_of(work, netInterface_priv_t, send_pkt_to_encrypt);
-    CsrUint16 interfaceTag = interfacePriv->InterfaceTag;
+    u16 interfaceTag = interfacePriv->InterfaceTag;
     unifi_priv_t *priv = interfacePriv->privPtr;
 
     CsrUint32 pktBulkDataLength;
diff --git a/drivers/staging/csr/unifi_sme.h b/drivers/staging/csr/unifi_sme.h
index 05de4cde889..bfe20d3d87a 100644
--- a/drivers/staging/csr/unifi_sme.h
+++ b/drivers/staging/csr/unifi_sme.h
@@ -77,16 +77,16 @@ typedef struct {
 
 
     /* SME's reply to a scan request */
-    CsrUint16 reply_scan_results_count;
+    u16 reply_scan_results_count;
     CsrWifiSmeScanResult* reply_scan_results;
 
 } sme_reply_t;
 
 
 typedef struct {
-    CsrUint16 appHandle;
+    u16 appHandle;
     CsrWifiRouterEncapsulation encapsulation;
-    CsrUint16 protocol;
+    u16 protocol;
     u8 oui[3];
     u8 in_use;
 } sme_ma_unidata_ind_filter_t;
@@ -95,11 +95,11 @@ typedef struct {
 CsrWifiRouterCtrlPortAction uf_sme_port_state(unifi_priv_t *priv,
                                           unsigned char *address,
                                           int queue,
-                                          CsrUint16 interfaceTag);
+                                          u16 interfaceTag);
 unifi_port_cfg_t *uf_sme_port_config_handle(unifi_priv_t *priv,
                                             unsigned char *address,
                                             int queue,
-                                            CsrUint16 interfaceTag);
+                                            u16 interfaceTag);
 
 
 
@@ -210,8 +210,8 @@ int sme_mgt_mib_get(unifi_priv_t *priv,
 int sme_mgt_mib_set(unifi_priv_t *priv,
                     unsigned char *varbind, int length);
 #ifdef CSR_SUPPORT_WEXT_AP
-int sme_ap_start(unifi_priv_t *priv,CsrUint16 interface_tag,CsrWifiSmeApConfig_t *ap_config);
-int sme_ap_stop(unifi_priv_t *priv,CsrUint16 interface_tag);
+int sme_ap_start(unifi_priv_t *priv,u16 interface_tag,CsrWifiSmeApConfig_t *ap_config);
+int sme_ap_stop(unifi_priv_t *priv,u16 interface_tag);
 int sme_ap_config(unifi_priv_t *priv,CsrWifiSmeApMacConfig *ap_mac_config, CsrWifiNmeApConfig *group_security_config);
 int uf_configure_supported_rates(u8 * supportedRates, u8 phySupportedBitmap);
 #endif
diff --git a/drivers/staging/csr/unifi_wext.h b/drivers/staging/csr/unifi_wext.h
index ac86df92d95..4ce0011d0ec 100644
--- a/drivers/staging/csr/unifi_wext.h
+++ b/drivers/staging/csr/unifi_wext.h
@@ -58,9 +58,9 @@ void wext_send_assoc_event(unifi_priv_t *priv, unsigned char *bssid,
                            unsigned char *scan_ie, unsigned int scan_ie_len);
 void wext_send_disassoc_event(unifi_priv_t *priv);
 void wext_send_michaelmicfailure_event(unifi_priv_t *priv,
-                                       CsrUint16 count, CsrWifiMacAddress address,
-                                       CsrWifiSmeKeyType keyType, CsrUint16 interfaceTag);
-void wext_send_pmkid_candidate_event(unifi_priv_t *priv, CsrWifiMacAddress bssid, CsrBool preauth_allowed, CsrUint16 interfaceTag);
+                                       u16 count, CsrWifiMacAddress address,
+                                       CsrWifiSmeKeyType keyType, u16 interfaceTag);
+void wext_send_pmkid_candidate_event(unifi_priv_t *priv, CsrWifiMacAddress bssid, CsrBool preauth_allowed, u16 interfaceTag);
 void wext_send_started_event(unifi_priv_t *priv);
 
 
diff --git a/drivers/staging/csr/unifiio.h b/drivers/staging/csr/unifiio.h
index c1e3f533870..74720fc3a19 100644
--- a/drivers/staging/csr/unifiio.h
+++ b/drivers/staging/csr/unifiio.h
@@ -205,9 +205,9 @@ typedef struct {
 
 typedef struct {
     /* Number of 16-bit ints in the protocols array */
-    CsrUint16 count;
+    u16 count;
     /* List of protocol ids to pass */
-    CsrUint16 *protocols;
+    u16 *protocols;
 } unifiio_snap_filter_t;
 
 
@@ -312,20 +312,20 @@ typedef struct uf_cfg_ap_config
 {
     u8    phySupportedBitmap;
     u8    channel;
-    CsrUint16   beaconInterval;
+    u16   beaconInterval;
     u8    dtimPeriod;
     CsrBool     wmmEnabled;
     u8    shortSlotTimeEnabled;
-    CsrUint16   groupkeyTimeout;
+    u16   groupkeyTimeout;
     CsrBool     strictGtkRekeyEnabled;
-    CsrUint16   gmkTimeout;
-    CsrUint16   responseTimeout;
+    u16   gmkTimeout;
+    u16   responseTimeout;
     u8    retransLimit;
     u8    rxStbc;
     CsrBool     rifsModeAllowed;
     u8    dualCtsProtection;
     u8    ctsProtectionType;
-    CsrUint16   maxListenInterval;
+    u16   maxListenInterval;
 }uf_cfg_ap_config_t;
 
 typedef struct tcpic_clsfr
diff --git a/drivers/staging/csr/wext_events.c b/drivers/staging/csr/wext_events.c
index 5674782b19a..f250ea60da5 100644
--- a/drivers/staging/csr/wext_events.c
+++ b/drivers/staging/csr/wext_events.c
@@ -217,10 +217,10 @@ _send_michaelmicfailure_event(struct net_device *dev,
 
 void
 wext_send_michaelmicfailure_event(unifi_priv_t *priv,
-                                  CsrUint16 count,
+                                  u16 count,
                                   CsrWifiMacAddress address,
                                   CsrWifiSmeKeyType keyType,
-                                  CsrUint16 interfaceTag)
+                                  u16 interfaceTag)
 {
     unsigned char tsc[8] = {0};
 
@@ -238,7 +238,7 @@ wext_send_michaelmicfailure_event(unifi_priv_t *priv,
 } /* wext_send_michaelmicfailure_event() */
 
 void
-wext_send_pmkid_candidate_event(unifi_priv_t *priv, CsrWifiMacAddress bssid, CsrBool preauth_allowed, CsrUint16 interfaceTag)
+wext_send_pmkid_candidate_event(unifi_priv_t *priv, CsrWifiMacAddress bssid, CsrBool preauth_allowed, u16 interfaceTag)
 {
 #if WIRELESS_EXT > 17
     union iwreq_data wrqu;