staging: csr: remove CsrUint8 typedef

Use the in-kernel u8 type instead.

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

77 files changed, 2504 insertions, 2505 deletions

diff --git a/drivers/staging/csr/bh.c b/drivers/staging/csr/bh.c
index 6af9d2953ea..bfc2f9ef1b6 100644
--- a/drivers/staging/csr/bh.c
+++ b/drivers/staging/csr/bh.c
@@ -159,7 +159,7 @@ uf_wait_for_thread_to_stop(unifi_priv_t *priv, struct uf_thread *thread)
 handle_bh_error(unifi_priv_t *priv)
 {
     u8 conf_param = CONFIG_IND_ERROR;
-    CsrUint8 interfaceTag = 0; /* used as a loop counter */
+    u8 interfaceTag = 0; /* used as a loop counter */
 
 
     /* Block unifi_run_bh() until the error has been handled. */
diff --git a/drivers/staging/csr/csr_lib.h b/drivers/staging/csr/csr_lib.h
index 171f5feeea9..041bd0950b3 100644
--- a/drivers/staging/csr/csr_lib.h
+++ b/drivers/staging/csr/csr_lib.h
@@ -35,7 +35,7 @@ CsrEvent *CsrEvent_struct(CsrUint16 primtype, CsrUint16 msgtype);
 typedef struct
 {
     CsrPrim  type;
-    CsrUint8 value;
+    u8 value;
 } CsrEventCsrUint8;
 
 /*----------------------------------------------------------------------------*
@@ -46,7 +46,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint8
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint8 *CsrEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint8 value);
+CsrEventCsrUint8 *CsrEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, u8 value);
 
 typedef struct
 {
@@ -68,7 +68,7 @@ typedef struct
 {
     CsrPrim   type;
     CsrUint16 value1;
-    CsrUint8  value2;
+    u8  value2;
 } CsrEventCsrUint16CsrUint8;
 
 /*----------------------------------------------------------------------------*
@@ -79,7 +79,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint16CsrUint8
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrUint8 *CsrEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrUint8 value2);
+CsrEventCsrUint16CsrUint8 *CsrEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, u8 value2);
 
 typedef struct
 {
diff --git a/drivers/staging/csr/csr_log.h b/drivers/staging/csr/csr_log.h
index db2653c30ea..f86c4920628 100644
--- a/drivers/staging/csr/csr_log.h
+++ b/drivers/staging/csr/csr_log.h
@@ -111,7 +111,7 @@ typedef struct
 /*---------------------------------*/
 /*  Tech logging */
 /*---------------------------------*/
-typedef CsrUint8 bitmask8_t;
+typedef u8 bitmask8_t;
 typedef CsrUint16 bitmask16_t;
 typedef CsrUint32 bitmask32_t;
 
@@ -168,13 +168,13 @@ void CsrLogStateTransition(bitmask16_t mask,
 /*---------------------------------*/
 /*  BSP logging */
 /*---------------------------------*/
-void CsrLogSchedInit(CsrUint8 thread_id);
-void CsrLogSchedDeinit(CsrUint8 thread_id);
+void CsrLogSchedInit(u8 thread_id);
+void CsrLogSchedDeinit(u8 thread_id);
 
-void CsrLogSchedStart(CsrUint8 thread_id);
-void CsrLogSchedStop(CsrUint8 thread_id);
+void CsrLogSchedStart(u8 thread_id);
+void CsrLogSchedStop(u8 thread_id);
 
-void CsrLogInitTask(CsrUint8 thread_id, CsrSchedQid tskid, const CsrCharString *tskName);
+void CsrLogInitTask(u8 thread_id, CsrSchedQid tskid, const CsrCharString *tskName);
 void CsrLogDeinitTask(CsrUint16 task_id);
 
 void CsrLogActivate(CsrSchedQid tskid);
@@ -218,7 +218,7 @@ void CsrLogTimedEventCancel(CsrUint32 line,
     CsrSchedTid tid,
     CsrBool cancel_res);
 
-void CsrLogBgintRegister(CsrUint8 thread_id,
+void CsrLogBgintRegister(u8 thread_id,
     CsrSchedBgint irq,
     const CsrCharString *callback,
     const void *ptr);
diff --git a/drivers/staging/csr/csr_log_configure.h b/drivers/staging/csr/csr_log_configure.h
index 3d48bf9762e..8c727adce76 100644
--- a/drivers/staging/csr/csr_log_configure.h
+++ b/drivers/staging/csr/csr_log_configure.h
@@ -20,7 +20,7 @@ extern "C" {
 /*---------------------------------*/
 /* Log init/deinit                 */
 /*---------------------------------*/
-void CsrLogInit(CsrUint8 size);
+void CsrLogInit(u8 size);
 void CsrLogDeinit(void);
 
 /*---------------------------------*/
diff --git a/drivers/staging/csr/csr_macro.h b/drivers/staging/csr/csr_macro.h
index 2e3dcac4f33..e8de0a7bab9 100644
--- a/drivers/staging/csr/csr_macro.h
+++ b/drivers/staging/csr/csr_macro.h
@@ -31,39 +31,39 @@ extern "C" {
 /*------------------------------------------------------------------*/
 /* Endian conversion */
 /*------------------------------------------------------------------*/
-#define CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr)        (((CsrUint16) ((CsrUint8 *) (ptr))[0]) | ((CsrUint16) ((CsrUint8 *) (ptr))[1]) << 8)
-#define CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr)        (((CsrUint32) ((CsrUint8 *) (ptr))[0]) | ((CsrUint32) ((CsrUint8 *) (ptr))[1]) << 8 | \
-                                                       ((CsrUint32) ((CsrUint8 *) (ptr))[2]) << 16 | ((CsrUint32) ((CsrUint8 *) (ptr))[3]) << 24)
-#define CSR_COPY_UINT16_TO_LITTLE_ENDIAN(uint, ptr)    ((CsrUint8 *) (ptr))[0] = ((CsrUint8) ((uint) & 0x00FF)); \
-    ((CsrUint8 *) (ptr))[1] = ((CsrUint8) ((uint) >> 8))
-#define CSR_COPY_UINT32_TO_LITTLE_ENDIAN(uint, ptr)    ((CsrUint8 *) (ptr))[0] = ((CsrUint8) ((uint) & 0x000000FF)); \
-    ((CsrUint8 *) (ptr))[1] = ((CsrUint8) (((uint) >> 8) & 0x000000FF)); \
-    ((CsrUint8 *) (ptr))[2] = ((CsrUint8) (((uint) >> 16) & 0x000000FF)); \
-    ((CsrUint8 *) (ptr))[3] = ((CsrUint8) (((uint) >> 24) & 0x000000FF))
-#define CSR_GET_UINT16_FROM_BIG_ENDIAN(ptr) (((CsrUint16) ((CsrUint8 *) (ptr))[1]) | ((CsrUint16) ((CsrUint8 *) (ptr))[0]) << 8)
-#define CSR_GET_UINT24_FROM_BIG_ENDIAN(ptr) (((CsrUint24) ((CsrUint8 *) (ptr))[2]) | \
-                                             ((CsrUint24) ((CsrUint8 *) (ptr))[1]) << 8 | ((CsrUint24) ((CsrUint8 *) (ptr))[0]) << 16)
-#define CSR_GET_UINT32_FROM_BIG_ENDIAN(ptr) (((CsrUint32) ((CsrUint8 *) (ptr))[3]) | ((CsrUint32) ((CsrUint8 *) (ptr))[2]) << 8 | \
-                                             ((CsrUint32) ((CsrUint8 *) (ptr))[1]) << 16 | ((CsrUint32) ((CsrUint8 *) (ptr))[0]) << 24)
-#define CSR_COPY_UINT16_TO_BIG_ENDIAN(uint, ptr)    ((CsrUint8 *) (ptr))[1] = ((CsrUint8) ((uint) & 0x00FF)); \
-    ((CsrUint8 *) (ptr))[0] = ((CsrUint8) ((uint) >> 8))
-#define CSR_COPY_UINT24_TO_BIG_ENDIAN(uint, ptr)    ((CsrUint8 *) (ptr))[2] = ((CsrUint8) ((uint) & 0x000000FF)); \
-    ((CsrUint8 *) (ptr))[1] = ((CsrUint8) (((uint) >> 8) & 0x000000FF)); \
-    ((CsrUint8 *) (ptr))[0] = ((CsrUint8) (((uint) >> 16) & 0x000000FF))
-#define CSR_COPY_UINT32_TO_BIG_ENDIAN(uint, ptr)    ((CsrUint8 *) (ptr))[3] = ((CsrUint8) ((uint) & 0x000000FF)); \
-    ((CsrUint8 *) (ptr))[2] = ((CsrUint8) (((uint) >> 8) & 0x000000FF)); \
-    ((CsrUint8 *) (ptr))[1] = ((CsrUint8) (((uint) >> 16) & 0x000000FF)); \
-    ((CsrUint8 *) (ptr))[0] = ((CsrUint8) (((uint) >> 24) & 0x000000FF))
+#define CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr)        (((CsrUint16) ((u8 *) (ptr))[0]) | ((CsrUint16) ((u8 *) (ptr))[1]) << 8)
+#define CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr)        (((CsrUint32) ((u8 *) (ptr))[0]) | ((CsrUint32) ((u8 *) (ptr))[1]) << 8 | \
+                                                       ((CsrUint32) ((u8 *) (ptr))[2]) << 16 | ((CsrUint32) ((u8 *) (ptr))[3]) << 24)
+#define CSR_COPY_UINT16_TO_LITTLE_ENDIAN(uint, ptr)    ((u8 *) (ptr))[0] = ((u8) ((uint) & 0x00FF)); \
+    ((u8 *) (ptr))[1] = ((u8) ((uint) >> 8))
+#define CSR_COPY_UINT32_TO_LITTLE_ENDIAN(uint, ptr)    ((u8 *) (ptr))[0] = ((u8) ((uint) & 0x000000FF)); \
+    ((u8 *) (ptr))[1] = ((u8) (((uint) >> 8) & 0x000000FF)); \
+    ((u8 *) (ptr))[2] = ((u8) (((uint) >> 16) & 0x000000FF)); \
+    ((u8 *) (ptr))[3] = ((u8) (((uint) >> 24) & 0x000000FF))
+#define CSR_GET_UINT16_FROM_BIG_ENDIAN(ptr) (((CsrUint16) ((u8 *) (ptr))[1]) | ((CsrUint16) ((u8 *) (ptr))[0]) << 8)
+#define CSR_GET_UINT24_FROM_BIG_ENDIAN(ptr) (((CsrUint24) ((u8 *) (ptr))[2]) | \
+                                             ((CsrUint24) ((u8 *) (ptr))[1]) << 8 | ((CsrUint24) ((u8 *) (ptr))[0]) << 16)
+#define CSR_GET_UINT32_FROM_BIG_ENDIAN(ptr) (((CsrUint32) ((u8 *) (ptr))[3]) | ((CsrUint32) ((u8 *) (ptr))[2]) << 8 | \
+                                             ((CsrUint32) ((u8 *) (ptr))[1]) << 16 | ((CsrUint32) ((u8 *) (ptr))[0]) << 24)
+#define CSR_COPY_UINT16_TO_BIG_ENDIAN(uint, ptr)    ((u8 *) (ptr))[1] = ((u8) ((uint) & 0x00FF)); \
+    ((u8 *) (ptr))[0] = ((u8) ((uint) >> 8))
+#define CSR_COPY_UINT24_TO_BIG_ENDIAN(uint, ptr)    ((u8 *) (ptr))[2] = ((u8) ((uint) & 0x000000FF)); \
+    ((u8 *) (ptr))[1] = ((u8) (((uint) >> 8) & 0x000000FF)); \
+    ((u8 *) (ptr))[0] = ((u8) (((uint) >> 16) & 0x000000FF))
+#define CSR_COPY_UINT32_TO_BIG_ENDIAN(uint, ptr)    ((u8 *) (ptr))[3] = ((u8) ((uint) & 0x000000FF)); \
+    ((u8 *) (ptr))[2] = ((u8) (((uint) >> 8) & 0x000000FF)); \
+    ((u8 *) (ptr))[1] = ((u8) (((uint) >> 16) & 0x000000FF)); \
+    ((u8 *) (ptr))[0] = ((u8) (((uint) >> 24) & 0x000000FF))
 
 /*------------------------------------------------------------------*/
 /* XAP conversion macros */
 /*------------------------------------------------------------------*/
 
-#define CSR_LSB16(a) ((CsrUint8) ((a) & 0x00ff))
-#define CSR_MSB16(b) ((CsrUint8) ((b) >> 8))
+#define CSR_LSB16(a) ((u8) ((a) & 0x00ff))
+#define CSR_MSB16(b) ((u8) ((b) >> 8))
 
 #define CSR_CONVERT_8_FROM_XAP(output, input) \
-    (output) = ((CsrUint8) (input));(input) += 2
+    (output) = ((u8) (input));(input) += 2
 
 #define CSR_CONVERT_16_FROM_XAP(output, input) \
     (output) = (CsrUint16) ((((CsrUint16) (input)[1]) << 8) | \
@@ -80,14 +80,14 @@ extern "C" {
     (output)[1] = 0;(output) += 2
 
 #define CSR_ADD_UINT16_TO_XAP(output, input) \
-    (output)[0] = ((CsrUint8) ((input) & 0x00FF));  \
-    (output)[1] = ((CsrUint8) ((input) >> 8));(output) += 2
+    (output)[0] = ((u8) ((input) & 0x00FF));  \
+    (output)[1] = ((u8) ((input) >> 8));(output) += 2
 
 #define CSR_ADD_UINT32_TO_XAP(output, input) \
-    (output)[0] = ((CsrUint8) (((input) >> 16) & 0x00FF)); \
-    (output)[1] = ((CsrUint8) ((input) >> 24)); \
-    (output)[2] = ((CsrUint8) ((input) & 0x00FF)); \
-    (output)[3] = ((CsrUint8) (((input) >> 8) & 0x00FF));(output) += 4
+    (output)[0] = ((u8) (((input) >> 16) & 0x00FF)); \
+    (output)[1] = ((u8) ((input) >> 24)); \
+    (output)[2] = ((u8) ((input) & 0x00FF)); \
+    (output)[3] = ((u8) (((input) >> 8) & 0x00FF));(output) += 4
 
 /*------------------------------------------------------------------*/
 /* Misc */
diff --git a/drivers/staging/csr/csr_msgconv.c b/drivers/staging/csr/csr_msgconv.c
index 9f1c946c66f..3f57b042c8f 100644
--- a/drivers/staging/csr/csr_msgconv.c
+++ b/drivers/staging/csr/csr_msgconv.c
@@ -73,10 +73,10 @@ static const CsrMsgConvMsgEntry *find_msg_converter(CsrMsgConvPrimEntry *ptr, Cs
 
 static void *deserialize_data(CsrUint16 primType,
     CsrSize length,
-    CsrUint8 *data)
+    u8 *data)
 {
     CsrMsgConvPrimEntry *ptr;
-    CsrUint8 *ret;
+    u8 *ret;
 
     ptr = CsrMsgConvFind(primType);
 
@@ -133,7 +133,7 @@ static CsrSize sizeof_message(CsrUint16 primType, void *msg)
     return ret;
 }
 
-static CsrBool free_message(CsrUint16 primType, CsrUint8 *data)
+static CsrBool free_message(CsrUint16 primType, u8 *data)
 {
     CsrMsgConvPrimEntry *ptr;
     CsrBool ret;
@@ -164,13 +164,13 @@ static CsrBool free_message(CsrUint16 primType, CsrUint8 *data)
     return ret;
 }
 
-static CsrUint8 *serialize_message(CsrUint16 primType,
+static u8 *serialize_message(CsrUint16 primType,
     void *msg,
     CsrSize *length,
-    CsrUint8 *buffer)
+    u8 *buffer)
 {
     CsrMsgConvPrimEntry *ptr;
-    CsrUint8 *ret;
+    u8 *ret;
 
     ptr = CsrMsgConvFind(primType);
 
@@ -203,13 +203,13 @@ CsrSize CsrMsgConvSizeof(CsrUint16 primType, void *msg)
     return sizeof_message(primType, msg);
 }
 
-CsrUint8 *CsrMsgConvSerialize(CsrUint8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg)
+u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg)
 {
     if (converter)
     {
         CsrSize serializedLength;
-        CsrUint8 *bufSerialized;
-        CsrUint8 *bufOffset = &buffer[*offset];
+        u8 *bufSerialized;
+        u8 *bufOffset = &buffer[*offset];
         bufSerialized = converter->serialize_message(primType, msg, &serializedLength, bufOffset);
         *offset += serializedLength;
         return bufSerialized;
diff --git a/drivers/staging/csr/csr_msgconv.h b/drivers/staging/csr/csr_msgconv.h
index 2875c8c6941..dd4853d5ce6 100644
--- a/drivers/staging/csr/csr_msgconv.h
+++ b/drivers/staging/csr/csr_msgconv.h
@@ -21,9 +21,9 @@ extern "C" {
 #endif
 
 typedef CsrSize (CsrMsgSizeofFunc)(void *msg);
-typedef CsrUint8 *(CsrMsgSerializeFunc)(CsrUint8 *buffer, CsrSize *length, void *msg);
+typedef u8 *(CsrMsgSerializeFunc)(u8 *buffer, CsrSize *length, void *msg);
 typedef void (CsrMsgFreeFunc)(void *msg);
-typedef void *(CsrMsgDeserializeFunc)(CsrUint8 *buffer, CsrSize length);
+typedef void *(CsrMsgDeserializeFunc)(u8 *buffer, CsrSize length);
 
 /* Converter entry for one message type */
 typedef struct CsrMsgConvMsgEntry
@@ -50,16 +50,16 @@ typedef struct CsrMsgConvPrimEntry
 typedef struct
 {
     CsrMsgConvPrimEntry *profile_converters;
-    void *(*deserialize_data)(CsrUint16 primType, CsrSize length, CsrUint8 * data);
-    CsrBool (*free_message)(CsrUint16 primType, CsrUint8 *data);
+    void *(*deserialize_data)(CsrUint16 primType, CsrSize length, u8 * data);
+    CsrBool (*free_message)(CsrUint16 primType, u8 *data);
     CsrSize (*sizeof_message)(CsrUint16 primType, void *msg);
-    CsrUint8 *(*serialize_message)(CsrUint16 primType, void *msg,
+    u8 *(*serialize_message)(CsrUint16 primType, void *msg,
                                    CsrSize * length,
-                                   CsrUint8 * buffer);
+                                   u8 * buffer);
 } CsrMsgConvEntry;
 
 CsrSize CsrMsgConvSizeof(CsrUint16 primType, void *msg);
-CsrUint8 *CsrMsgConvSerialize(CsrUint8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg);
+u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg);
 void CsrMsgConvCustomLookupRegister(CsrUint16 primType, CsrMsgCustomLookupFunc *lookupFunc);
 void CsrMsgConvInsert(CsrUint16 primType, const CsrMsgConvMsgEntry *ce);
 CsrMsgConvPrimEntry *CsrMsgConvFind(CsrUint16 primType);
@@ -78,65 +78,65 @@ CsrUint32 CsrUtf8StringSerLen(const CsrUtf8String *str);
 CsrUint32 CsrUtf16StringSerLen(const CsrUtf16String *str);
 
 /* Prototypes for primitive type serializers */
-void CsrUint8Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint8 value);
-void CsrUint16Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint16 value);
-void CsrUint32Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint32 value);
-void CsrMemCpySer(CsrUint8 *buffer, CsrSize *offset, const void *value, CsrSize length);
-void CsrCharStringSer(CsrUint8 *buffer, CsrSize *offset, const CsrCharString *value);
-void CsrUtf8StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf8String *value);
-void CsrUtf16StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf16String *value);
-void CsrVoidPtrSer(CsrUint8 *buffer, CsrSize *offset, void *ptr);
-void CsrSizeSer(CsrUint8 *buffer, CsrSize *offset, CsrSize value);
-
-void CsrUint8Des(CsrUint8 *value, CsrUint8 *buffer, CsrSize *offset);
-void CsrUint16Des(CsrUint16 *value, CsrUint8 *buffer, CsrSize *offset);
-void CsrUint32Des(CsrUint32 *value, CsrUint8 *buffer, CsrSize *offset);
-void CsrMemCpyDes(void *value, CsrUint8 *buffer, CsrSize *offset, CsrSize length);
-void CsrCharStringDes(CsrCharString **value, CsrUint8 *buffer, CsrSize *offset);
-void CsrUtf8StringDes(CsrUtf8String **value, CsrUint8 *buffer, CsrSize *offset);
-void CsrUtf16StringDes(CsrUtf16String **value, CsrUint8 *buffer, CsrSize *offset);
-void CsrVoidPtrDes(void **value, CsrUint8 *buffer, CsrSize *offset);
-void CsrSizeDes(CsrSize *value, CsrUint8 *buffer, CsrSize *offset);
+void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value);
+void CsrUint16Ser(u8 *buffer, CsrSize *offset, CsrUint16 value);
+void CsrUint32Ser(u8 *buffer, CsrSize *offset, CsrUint32 value);
+void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length);
+void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value);
+void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value);
+void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const CsrUtf16String *value);
+void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr);
+void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value);
+
+void CsrUint8Des(u8 *value, u8 *buffer, CsrSize *offset);
+void CsrUint16Des(CsrUint16 *value, u8 *buffer, CsrSize *offset);
+void CsrUint32Des(CsrUint32 *value, u8 *buffer, CsrSize *offset);
+void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length);
+void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset);
+void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset);
+void CsrUtf16StringDes(CsrUtf16String **value, u8 *buffer, CsrSize *offset);
+void CsrVoidPtrDes(void **value, u8 *buffer, CsrSize *offset);
+void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset);
 
 CsrSize CsrEventSizeof(void *msg);
-CsrUint8 *CsrEventSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventDes(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventDes(u8 *buffer, CsrSize length);
 
 CsrSize CsrEventCsrUint8Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint8Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint8Des(u8 *buffer, CsrSize length);
 
 CsrSize CsrEventCsrUint16Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16Des(u8 *buffer, CsrSize length);
 
 CsrSize CsrEventCsrUint32Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint32Des(u8 *buffer, CsrSize length);
 
 CsrSize CsrEventCsrUint16CsrUint8Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length);
 
 CsrSize CsrEventCsrUint16CsrUint16Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint16CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint16Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length);
 
 CsrSize CsrEventCsrUint16CsrUint32Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint16CsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint32Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length);
 
 CsrSize CsrEventCsrUint16CsrCharStringSizeof(void *msg);
-CsrUint8 *CsrEventCsrUint16CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrCharStringDes(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length);
 
 CsrSize CsrEventCsrUint32CsrUint16Sizeof(void *msg);
-CsrUint8 *CsrEventCsrUint32CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32CsrUint16Des(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length);
 
 CsrSize CsrEventCsrUint32CsrCharStringSizeof(void *msg);
-CsrUint8 *CsrEventCsrUint32CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32CsrCharStringDes(CsrUint8 *buffer, CsrSize length);
+u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, CsrSize length);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_panic.c b/drivers/staging/csr/csr_panic.c
index 2564e80297e..87c72ad50f8 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(CsrUint8 tech, CsrUint16 reason, const char *p)
+void CsrPanic(u8 tech, CsrUint16 reason, const char *p)
 {
     BUG_ON(1);
 }
diff --git a/drivers/staging/csr/csr_panic.h b/drivers/staging/csr/csr_panic.h
index 6e33f9337b2..2b7166873e8 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(CsrUint8 tech, CsrUint16 reason, const char *p);
+void CsrPanic(u8 tech, CsrUint16 reason, const char *p);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_pmem.h b/drivers/staging/csr/csr_pmem.h
index f1e59ef83c6..4007915cc4c 100644
--- a/drivers/staging/csr/csr_pmem.h
+++ b/drivers/staging/csr/csr_pmem.h
@@ -102,7 +102,7 @@ void CsrPmemFree(void *ptr);
  *----------------------------------------------------------------------------*/
 #ifdef CSR_PMEM_DEBUG_ENABLE
 
-typedef CsrUint8 CsrPmemDebugAllocType;
+typedef u8 CsrPmemDebugAllocType;
 #define CSR_PMEM_DEBUG_TYPE_PMEM_ALLOC    1
 #define CSR_PMEM_DEBUG_TYPE_MEM_ALLOC     2
 #define CSR_PMEM_DEBUG_TYPE_MEM_CALLOC    3
@@ -125,7 +125,7 @@ typedef void (CsrPmemDebugOnFree)(void *ptr, void *userptr, CsrPmemDebugAllocTyp
  *      void
  *
  *----------------------------------------------------------------------------*/
-void CsrPmemDebugInstallHooks(CsrUint8 headSize, CsrUint8 endSize, CsrPmemDebugOnAlloc *onAllocCallback, CsrPmemDebugOnFree *onFreeCallback);
+void CsrPmemDebugInstallHooks(u8 headSize, u8 endSize, CsrPmemDebugOnAlloc *onAllocCallback, CsrPmemDebugOnFree *onFreeCallback);
 
 void *CsrPmemDebugAlloc(CsrSize size, CsrPmemDebugAllocType type, const CsrCharString* file, CsrUint32 line);
 #define CsrPmemAlloc(size) CsrPmemDebugAlloc(size, CSR_PMEM_DEBUG_TYPE_PMEM_ALLOC, __FILE__, __LINE__)
diff --git a/drivers/staging/csr/csr_sdio.h b/drivers/staging/csr/csr_sdio.h
index d60ef45a9ab..2ce4f167d1b 100644
--- a/drivers/staging/csr/csr_sdio.h
+++ b/drivers/staging/csr/csr_sdio.h
@@ -54,8 +54,8 @@ 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 */
-    CsrUint8  sdioFunction; /* SDIO Function number to match or CSR_SDIO_ANY_SDIO_FUNCTION */
-    CsrUint8  sdioInterface; /* SDIO Standard Interface Code to match or CSR_SDIO_ANY_SDIO_INTERFACE */
+    u8  sdioFunction; /* SDIO Function number to match or CSR_SDIO_ANY_SDIO_FUNCTION */
+    u8  sdioInterface; /* SDIO Standard Interface Code to match or CSR_SDIO_ANY_SDIO_INTERFACE */
 } CsrSdioFunctionId;
 
 /*----------------------------------------------------------------------------*
@@ -204,7 +204,7 @@ typedef struct
     CsrSdioSuspendCallback   suspend;
     CsrSdioResumeCallback    resume;
     CsrSdioFunctionId       *ids;
-    CsrUint8                 idsCount;
+    u8                 idsCount;
     void                    *priv;          /* For use by the SDIO Driver */
 } CsrSdioFunctionDriver;
 
@@ -519,10 +519,10 @@ CsrResult CsrSdioMaxBusClockFrequencySet(CsrSdioFunction *function, CsrUint32 ma
  *            the callback function.
  *
  *----------------------------------------------------------------------------*/
-CsrResult CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data);
-CsrResult CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data);
-void CsrSdioRead8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data, CsrSdioAsyncCallback callback);
-void CsrSdioWrite8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data, CsrSdioAsyncCallback callback);
+CsrResult CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, u8 *data);
+CsrResult CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, u8 data);
+void CsrSdioRead8Async(CsrSdioFunction *function, CsrUint32 address, u8 *data, CsrSdioAsyncCallback callback);
+void CsrSdioWrite8Async(CsrSdioFunction *function, CsrUint32 address, u8 data, CsrSdioAsyncCallback callback);
 
 /*----------------------------------------------------------------------------*
  *  NAME
@@ -608,10 +608,10 @@ void CsrSdioWrite16Async(CsrSdioFunction *function, CsrUint32 address, CsrUint16
  *            the callback function.
  *
  *----------------------------------------------------------------------------*/
-CsrResult CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data);
-CsrResult CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data);
-void CsrSdioF0Read8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data, CsrSdioAsyncCallback callback);
-void CsrSdioF0Write8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data, CsrSdioAsyncCallback callback);
+CsrResult CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, u8 *data);
+CsrResult CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, u8 data);
+void CsrSdioF0Read8Async(CsrSdioFunction *function, CsrUint32 address, u8 *data, CsrSdioAsyncCallback callback);
+void CsrSdioF0Write8Async(CsrSdioFunction *function, CsrUint32 address, u8 data, CsrSdioAsyncCallback callback);
 
 /*----------------------------------------------------------------------------*
  *  NAME
diff --git a/drivers/staging/csr/csr_serialize_primitive_types.c b/drivers/staging/csr/csr_serialize_primitive_types.c
index 5ea06fc964d..41bd4bec9eb 100644
--- a/drivers/staging/csr/csr_serialize_primitive_types.c
+++ b/drivers/staging/csr/csr_serialize_primitive_types.c
@@ -16,14 +16,14 @@
 #include "csr_pmem.h"
 #include "csr_lib.h"
 
-void CsrUint8Des(CsrUint8 *value, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint8Des(u8 *value, u8 *buffer, CsrSize *offset)
 {
     *value = buffer[*offset];
     *offset += sizeof(*value);
 }
 EXPORT_SYMBOL_GPL(CsrUint8Des);
 
-void CsrUint16Des(CsrUint16 *value, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint16Des(CsrUint16 *value, u8 *buffer, CsrSize *offset)
 {
     *value = (buffer[*offset + 0] << 0) |
              (buffer[*offset + 1] << 8);
@@ -31,7 +31,7 @@ void CsrUint16Des(CsrUint16 *value, CsrUint8 *buffer, CsrSize *offset)
 }
 EXPORT_SYMBOL_GPL(CsrUint16Des);
 
-void CsrUint32Des(CsrUint32 *value, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint32Des(CsrUint32 *value, u8 *buffer, CsrSize *offset)
 {
     *value = (buffer[*offset + 0] << 0) |
              (buffer[*offset + 1] << 8) |
@@ -41,27 +41,27 @@ void CsrUint32Des(CsrUint32 *value, CsrUint8 *buffer, CsrSize *offset)
 }
 EXPORT_SYMBOL_GPL(CsrUint32Des);
 
-void CsrMemCpyDes(void *value, CsrUint8 *buffer, CsrSize *offset, CsrSize length)
+void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length)
 {
     CsrMemCpy(value, &buffer[*offset], length);
     *offset += length;
 }
 EXPORT_SYMBOL_GPL(CsrMemCpyDes);
 
-void CsrCharStringDes(CsrCharString **value, CsrUint8 *buffer, CsrSize *offset)
+void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset)
 {
     *value = CsrStrDup((CsrCharString *) &buffer[*offset]);
     *offset += CsrStrLen(*value) + 1;
 }
 EXPORT_SYMBOL_GPL(CsrCharStringDes);
 
-void CsrUtf8StringDes(CsrUtf8String **value, CsrUint8 *buffer, CsrSize *offset)
+void CsrUtf8StringDes(CsrUtf8String **value, u8 *buffer, CsrSize *offset)
 {
     *value = (CsrUtf8String *) CsrStrDup((CsrCharString *) &buffer[*offset]);
     *offset += CsrStrLen((CsrCharString *) *value) + 1;
 }
 
-void CsrUtf16StringDes(CsrUtf16String **value, CsrUint8 *buffer, CsrSize *offset)
+void CsrUtf16StringDes(CsrUtf16String **value, u8 *buffer, CsrSize *offset)
 {
     CsrUint32 length, i;
 
@@ -74,7 +74,7 @@ void CsrUtf16StringDes(CsrUtf16String **value, CsrUint8 *buffer, CsrSize *offset
     }
 }
 
-void CsrSizeDes(CsrSize *value, CsrUint8 *buffer, CsrSize *offset)
+void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset)
 {
     *value = (buffer[*offset + 0] << 0) |
              (buffer[*offset + 1] << 8) |
@@ -83,44 +83,44 @@ void CsrSizeDes(CsrSize *value, CsrUint8 *buffer, CsrSize *offset)
     *offset += sizeof(*value);
 }
 
-void CsrVoidPtrDes(void **value, CsrUint8 *buffer, CsrSize *offset)
+void CsrVoidPtrDes(void **value, u8 *buffer, CsrSize *offset)
 {
     CsrSizeDes((CsrSize *) value, buffer, offset);
 }
 
-void CsrUint8Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint8 value)
+void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value)
 {
     buffer[*offset] = value;
     *offset += sizeof(value);
 }
 EXPORT_SYMBOL_GPL(CsrUint8Ser);
 
-void CsrUint16Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint16 value)
+void CsrUint16Ser(u8 *buffer, CsrSize *offset, CsrUint16 value)
 {
-    buffer[*offset + 0] = (CsrUint8) ((value >> 0) & 0xFF);
-    buffer[*offset + 1] = (CsrUint8) ((value >> 8) & 0xFF);
+    buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
+    buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
     *offset += sizeof(value);
 }
 EXPORT_SYMBOL_GPL(CsrUint16Ser);
 
-void CsrUint32Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint32 value)
+void CsrUint32Ser(u8 *buffer, CsrSize *offset, CsrUint32 value)
 {
-    buffer[*offset + 0] = (CsrUint8) ((value >> 0) & 0xFF);
-    buffer[*offset + 1] = (CsrUint8) ((value >> 8) & 0xFF);
-    buffer[*offset + 2] = (CsrUint8) ((value >> 16) & 0xFF);
-    buffer[*offset + 3] = (CsrUint8) ((value >> 24) & 0xFF);
+    buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
+    buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
+    buffer[*offset + 2] = (u8) ((value >> 16) & 0xFF);
+    buffer[*offset + 3] = (u8) ((value >> 24) & 0xFF);
     *offset += sizeof(value);
 }
 EXPORT_SYMBOL_GPL(CsrUint32Ser);
 
-void CsrMemCpySer(CsrUint8 *buffer, CsrSize *offset, const void *value, CsrSize length)
+void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length)
 {
     CsrMemCpy(&buffer[*offset], value, length);
     *offset += length;
 }
 EXPORT_SYMBOL_GPL(CsrMemCpySer);
 
-void CsrCharStringSer(CsrUint8 *buffer, CsrSize *offset, const CsrCharString *value)
+void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value)
 {
     if (value)
     {
@@ -134,12 +134,12 @@ void CsrCharStringSer(CsrUint8 *buffer, CsrSize *offset, const CsrCharString *va
 }
 EXPORT_SYMBOL_GPL(CsrCharStringSer);
 
-void CsrUtf8StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf8String *value)
+void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const CsrUtf8String *value)
 {
     CsrCharStringSer(buffer, offset, (CsrCharString *) value);
 }
 
-void CsrUtf16StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf16String *value)
+void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const CsrUtf16String *value)
 {
     if (value)
     {
@@ -159,16 +159,16 @@ void CsrUtf16StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf16String *
     }
 }
 
-void CsrSizeSer(CsrUint8 *buffer, CsrSize *offset, CsrSize value)
+void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value)
 {
-    buffer[*offset + 0] = (CsrUint8) ((value >> 0) & 0xFF);
-    buffer[*offset + 1] = (CsrUint8) ((value >> 8) & 0xFF);
-    buffer[*offset + 2] = (CsrUint8) ((value >> 16) & 0xFF);
-    buffer[*offset + 3] = (CsrUint8) ((value >> 24) & 0xFF);
+    buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
+    buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
+    buffer[*offset + 2] = (u8) ((value >> 16) & 0xFF);
+    buffer[*offset + 3] = (u8) ((value >> 24) & 0xFF);
     *offset += sizeof(value);
 }
 
-void CsrVoidPtrSer(CsrUint8 *buffer, CsrSize *offset, void *ptr)
+void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr)
 {
     CsrSizeSer(buffer, offset, (CsrSize) ptr);
 }
@@ -215,7 +215,7 @@ CsrSize CsrEventSizeof(void *msg)
     return 2;
 }
 
-CsrUint8 *CsrEventSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrEvent *primitive = (CsrEvent *) msg;
     *len = 0;
@@ -223,7 +223,7 @@ CsrUint8 *CsrEventSer(CsrUint8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventDes(CsrUint8 *buffer, CsrSize length)
+void *CsrEventDes(u8 *buffer, CsrSize length)
 {
     CsrEvent *primitive = (CsrEvent *) CsrPmemAlloc(sizeof(CsrEvent));
     CsrSize offset = 0;
@@ -237,7 +237,7 @@ CsrSize CsrEventCsrUint8Sizeof(void *msg)
     return 3;
 }
 
-CsrUint8 *CsrEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) msg;
     *len = 0;
@@ -246,7 +246,7 @@ CsrUint8 *CsrEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint8Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint8Des(u8 *buffer, CsrSize length)
 {
     CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrEventCsrUint8));
 
@@ -262,7 +262,7 @@ CsrSize CsrEventCsrUint16Sizeof(void *msg)
     return 4;
 }
 
-CsrUint8 *CsrEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) msg;
     *len = 0;
@@ -271,7 +271,7 @@ CsrUint8 *CsrEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint16Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint16Des(u8 *buffer, CsrSize length)
 {
     CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16));
 
@@ -287,7 +287,7 @@ CsrSize CsrEventCsrUint32Sizeof(void *msg)
     return 6;
 }
 
-CsrUint8 *CsrEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) msg;
     *len = 0;
@@ -296,7 +296,7 @@ CsrUint8 *CsrEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint32Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint32Des(u8 *buffer, CsrSize length)
 {
     CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrEventCsrUint32));
 
@@ -312,7 +312,7 @@ CsrSize CsrEventCsrUint16CsrUint8Sizeof(void *msg)
     return 5;
 }
 
-CsrUint8 *CsrEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) msg;
     *len = 0;
@@ -322,7 +322,7 @@ CsrUint8 *CsrEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length)
 {
     CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint8));
 
@@ -339,7 +339,7 @@ CsrSize CsrEventCsrUint16CsrUint16Sizeof(void *msg)
     return 6;
 }
 
-CsrUint8 *CsrEventCsrUint16CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) msg;
     *len = 0;
@@ -349,7 +349,7 @@ CsrUint8 *CsrEventCsrUint16CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint16CsrUint16Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length)
 {
     CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint16));
 
@@ -366,7 +366,7 @@ CsrSize CsrEventCsrUint16CsrUint32Sizeof(void *msg)
     return 8;
 }
 
-CsrUint8 *CsrEventCsrUint16CsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) msg;
     *len = 0;
@@ -376,7 +376,7 @@ CsrUint8 *CsrEventCsrUint16CsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint16CsrUint32Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length)
 {
     CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint32));
 
@@ -394,7 +394,7 @@ CsrSize CsrEventCsrUint16CsrCharStringSizeof(void *msg)
     return 4 + CsrStrLen(primitive->value2) + 1;
 }
 
-CsrUint8 *CsrEventCsrUint16CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
     *len = 0;
@@ -404,7 +404,7 @@ CsrUint8 *CsrEventCsrUint16CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *m
     return ptr;
 }
 
-void *CsrEventCsrUint16CsrCharStringDes(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length)
 {
     CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrCharString));
 
@@ -421,7 +421,7 @@ CsrSize CsrEventCsrUint32CsrUint16Sizeof(void *msg)
     return 8;
 }
 
-CsrUint8 *CsrEventCsrUint32CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) msg;
     *len = 0;
@@ -431,7 +431,7 @@ CsrUint8 *CsrEventCsrUint32CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
     return ptr;
 }
 
-void *CsrEventCsrUint32CsrUint16Des(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length)
 {
     CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint32CsrUint16));
 
@@ -449,7 +449,7 @@ CsrSize CsrEventCsrUint32CsrCharStringSizeof(void *msg)
     return 6 + CsrStrLen(primitive->value2) + 1;
 }
 
-CsrUint8 *CsrEventCsrUint32CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
     *len = 0;
@@ -459,7 +459,7 @@ CsrUint8 *CsrEventCsrUint32CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *m
     return ptr;
 }
 
-void *CsrEventCsrUint32CsrCharStringDes(CsrUint8 *buffer, CsrSize length)
+void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, CsrSize length)
 {
     CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) CsrPmemAlloc(sizeof(CsrEventCsrUint32CsrCharString));
 
diff --git a/drivers/staging/csr/csr_types.h b/drivers/staging/csr/csr_types.h
index e736a78da43..683e07772bf 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 uint8_t CsrUint8;
 typedef uint16_t CsrUint16;
 typedef uint32_t CsrUint32;
 
@@ -43,11 +42,11 @@ typedef int16_t CsrInt16;
 typedef int32_t CsrInt32;
 
 /* Boolean */
-typedef CsrUint8 CsrBool;
+typedef u8 CsrBool;
 
 /* String types */
 typedef char CsrCharString;
-typedef CsrUint8 CsrUtf8String;
+typedef u8 CsrUtf8String;
 typedef CsrUint16 CsrUtf16String;   /* 16-bit UTF16 strings */
 typedef CsrUint32 CsrUint24;
 
diff --git a/drivers/staging/csr/csr_unicode.h b/drivers/staging/csr/csr_unicode.h
index 9faf8567a5a..3d86de424b9 100644
--- a/drivers/staging/csr/csr_unicode.h
+++ b/drivers/staging/csr/csr_unicode.h
@@ -172,16 +172,16 @@ CsrUtf8String *CsrUtf8StringConcatenateTexts(const CsrUtf8String *inputText1, co
  *
  * D-13157
  */
-typedef CsrUint8 CsrUcs2String;
+typedef u8 CsrUcs2String;
 
 CsrSize CsrUcs2ByteStrLen(const CsrUcs2String *ucs2String);
 CsrSize CsrConverterUcs2ByteStrLen(const CsrUcs2String *str);
 
-CsrUint8 *CsrUcs2ByteString2Utf8(const CsrUcs2String *ucs2String);
-CsrUcs2String *CsrUtf82Ucs2ByteString(const CsrUint8 *utf8String);
+u8 *CsrUcs2ByteString2Utf8(const CsrUcs2String *ucs2String);
+CsrUcs2String *CsrUtf82Ucs2ByteString(const u8 *utf8String);
 
-CsrUint8 *CsrUtf16String2Ucs2ByteString(const CsrUtf16String *source);
-CsrUtf16String *CsrUcs2ByteString2Utf16String(const CsrUint8 *source);
+u8 *CsrUtf16String2Ucs2ByteString(const CsrUtf16String *source);
+CsrUtf16String *CsrUcs2ByteString2Utf16String(const u8 *source);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_utf16.c b/drivers/staging/csr/csr_utf16.c
index 9259635851f..42fb7b0f968 100644
--- a/drivers/staging/csr/csr_utf16.c
+++ b/drivers/staging/csr/csr_utf16.c
@@ -18,7 +18,7 @@
 #define UNI_SUR_LOW_START    ((CsrUint32) 0xDC00)
 #define UNI_SUR_LOW_END      ((CsrUint32) 0xDFFF)
 #define UNI_REPLACEMENT_CHAR ((CsrUint32) 0xFFFD)
-#define UNI_HALF_SHIFT       ((CsrUint8) 10)  /* used for shifting by 10 bits */
+#define UNI_HALF_SHIFT       ((u8) 10)  /* used for shifting by 10 bits */
 #define UNI_HALF_BASE        ((CsrUint32) 0x00010000)
 #define UNI_BYTEMASK         ((CsrUint32) 0xBF)
 #define UNI_BYTEMARK         ((CsrUint32) 0x80)
@@ -152,7 +152,7 @@ CsrUint32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString)
 *********************************************************************************/
 CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, CsrUint32 count)
 {
-    return CsrMemCpy((CsrUint8 *) dest, (CsrUint8 *) src, count * sizeof(CsrUtf16String));
+    return CsrMemCpy((u8 *) dest, (u8 *) src, count * sizeof(CsrUtf16String));
 }
 
 /********************************************************************************
@@ -260,10 +260,10 @@ CsrUtf8String *CsrUtf16String2Utf8(const CsrUtf16String *source)
     CsrUint32 ch;
     CsrUint32 length;
     CsrUint32 sourceLength;
-    CsrUint8 bytes;
+    u8 bytes;
     CsrBool appendNull = FALSE;
 
-    CsrUint8 firstByteMark[5] = {0x00, 0x00, 0xC0, 0xE0, 0xF0};
+    u8 firstByteMark[5] = {0x00, 0x00, 0xC0, 0xE0, 0xF0};
 
     if (!source)
     {
@@ -384,25 +384,25 @@ CsrUtf8String *CsrUtf16String2Utf8(const CsrUtf16String *source)
         {
             case 4:
             {
-                *--dest = (CsrUint8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
+                *--dest = (u8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
                 ch >>= 6;
             }
             /* FALLTHROUGH */
             case 3:
             {
-                *--dest = (CsrUint8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
+                *--dest = (u8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
                 ch >>= 6;
             }
             /* FALLTHROUGH */
             case 2:
             {
-                *--dest = (CsrUint8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
+                *--dest = (u8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
                 ch >>= 6;
             }
             /* FALLTHROUGH */
             case 1:
             {
-                *--dest = (CsrUint8) (ch | firstByteMark[bytes]);
+                *--dest = (u8) (ch | firstByteMark[bytes]);
             }
             /* FALLTHROUGH */
             default:
@@ -466,7 +466,7 @@ CsrUtf8String *CsrUtf16String2Utf8(const CsrUtf16String *source)
 static CsrBool isLegalUtf8(const CsrUtf8String *codeUnit, CsrUint32 length)
 {
     const CsrUtf8String *srcPtr = codeUnit + length;
-    CsrUint8 byte;
+    u8 byte;
 
     switch (length) /* Everything falls through except case 1 */
     {
diff --git a/drivers/staging/csr/csr_util.c b/drivers/staging/csr/csr_util.c
index ee2d0475781..83721fe8654 100644
--- a/drivers/staging/csr/csr_util.c
+++ b/drivers/staging/csr/csr_util.c
@@ -21,9 +21,9 @@
 /*------------------------------------------------------------------*/
 
 /* Time proportional with the number of 1's */
-CsrUint8 CsrBitCountSparse(CsrUint32 n)
+u8 CsrBitCountSparse(CsrUint32 n)
 {
-    CsrUint8 count = 0;
+    u8 count = 0;
 
     while (n)
     {
@@ -35,9 +35,9 @@ CsrUint8 CsrBitCountSparse(CsrUint32 n)
 }
 
 /* Time proportional with the number of 0's */
-CsrUint8 CsrBitCountDense(CsrUint32 n)
+u8 CsrBitCountDense(CsrUint32 n)
 {
-    CsrUint8 count = 8 * sizeof(CsrUint32);
+    u8 count = 8 * sizeof(CsrUint32);
 
     n ^= (CsrUint32) (-1);
 
@@ -53,7 +53,7 @@ CsrUint8 CsrBitCountDense(CsrUint32 n)
 /*------------------------------------------------------------------*/
 /* Base conversion */
 /*------------------------------------------------------------------*/
-CsrBool CsrHexStrToUint8(const CsrCharString *string, CsrUint8 *returnValue)
+CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue)
 {
     CsrUint16 currentIndex = 0;
     *returnValue = 0;
@@ -65,7 +65,7 @@ CsrBool CsrHexStrToUint8(const CsrCharString *string, CsrUint8 *returnValue)
     {
         while (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
         {
-            *returnValue = (CsrUint8) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
+            *returnValue = (u8) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
             currentIndex++;
             if (currentIndex >= 2)
             {
@@ -148,7 +148,7 @@ CsrUint32 CsrPow(CsrUint32 base, CsrUint32 exponent)
 void CsrIntToBase10(CsrInt32 number, CsrCharString *str)
 {
     CsrInt32 digit;
-    CsrUint8 index;
+    u8 index;
     CsrCharString res[I2B10_MAX];
     CsrBool foundDigit = FALSE;
 
@@ -228,7 +228,7 @@ void *CsrMemCpy(void *dest, const void *src, CsrSize count)
 }
 EXPORT_SYMBOL_GPL(CsrMemCpy);
 
-void *CsrMemSet(void *dest, CsrUint8 c, CsrSize count)
+void *CsrMemSet(void *dest, u8 c, CsrSize count)
 {
     return memset(dest, c, count);
 }
@@ -423,7 +423,7 @@ const CsrCharString *CsrGetBaseName(const CsrCharString *file)
 /*------------------------------------------------------------------*/
 /* Misc */
 /*------------------------------------------------------------------*/
-CsrBool CsrIsSpace(CsrUint8 c)
+CsrBool CsrIsSpace(u8 c)
 {
     switch (c)
     {
diff --git a/drivers/staging/csr/csr_util.h b/drivers/staging/csr/csr_util.h
index 5cd6cb4f22c..e48dcbb20e3 100644
--- a/drivers/staging/csr/csr_util.h
+++ b/drivers/staging/csr/csr_util.h
@@ -20,13 +20,13 @@ extern "C" {
 /*------------------------------------------------------------------*/
 /* Bits - intended to operate on CsrUint32 values */
 /*------------------------------------------------------------------*/
-CsrUint8 CsrBitCountSparse(CsrUint32 n);
-CsrUint8 CsrBitCountDense(CsrUint32 n);
+u8 CsrBitCountSparse(CsrUint32 n);
+u8 CsrBitCountDense(CsrUint32 n);
 
 /*------------------------------------------------------------------*/
 /* Base conversion */
 /*------------------------------------------------------------------*/
-CsrBool CsrHexStrToUint8(const CsrCharString *string, CsrUint8 *returnValue);
+CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue);
 CsrBool CsrHexStrToUint16(const CsrCharString *string, CsrUint16 *returnValue);
 CsrBool CsrHexStrToUint32(const CsrCharString *string, CsrUint32 *returnValue);
 CsrUint32 CsrPow(CsrUint32 base, CsrUint32 exponent);
@@ -63,7 +63,7 @@ CsrInt32 CsrStrCmp(const CsrCharString *string1, const CsrCharString *string2);
 CsrInt32 CsrStrNCmp(const CsrCharString *string1, const CsrCharString *string2, CsrSize count);
 CsrCharString *CsrStrChr(const CsrCharString *string, CsrCharString c);
 CsrCharString *CsrStrStr(const CsrCharString *string1, const CsrCharString *string2);
-void *CsrMemSet(void *dest, CsrUint8 c, CsrSize count);
+void *CsrMemSet(void *dest, u8 c, CsrSize count);
 CsrSize CsrStrLen(const CsrCharString *string);
 #endif /* !CSR_USE_STDC_LIB */
 CsrInt32 CsrVsnprintf(CsrCharString *string, CsrSize count, const CsrCharString *format, va_list args);
@@ -85,7 +85,7 @@ const CsrCharString *CsrGetBaseName(const CsrCharString *file);
 /*------------------------------------------------------------------*/
 /* Misc */
 /*------------------------------------------------------------------*/
-CsrBool CsrIsSpace(CsrUint8 c);
+CsrBool CsrIsSpace(u8 c);
 #define CsrOffsetOf(st, m)  ((CsrSize) & ((st *) 0)->m)
 
 #ifdef __cplusplus
diff --git a/drivers/staging/csr/csr_wifi_common.h b/drivers/staging/csr/csr_wifi_common.h
index 442dcc6e4e0..df04a8bbd4f 100644
--- a/drivers/staging/csr/csr_wifi_common.h
+++ b/drivers/staging/csr/csr_wifi_common.h
@@ -21,25 +21,25 @@ extern "C" {
 /* MAC address */
 typedef struct
 {
-    CsrUint8 a[6];
+    u8 a[6];
 } CsrWifiMacAddress;
 
 /* IPv4 address */
 typedef struct
 {
-    CsrUint8 a[4];
+    u8 a[4];
 } CsrWifiIp4Address;
 
 /* IPv6 address */
 typedef struct
 {
-    CsrUint8 a[16];
+    u8 a[16];
 } CsrWifiIp6Address;
 
 typedef struct
 {
-    CsrUint8 ssid[32];
-    CsrUint8 length;
+    u8 ssid[32];
+    u8 length;
 } CsrWifiSsid;
 
 /*******************************************************************************
diff --git a/drivers/staging/csr/csr_wifi_fsm_types.h b/drivers/staging/csr/csr_wifi_fsm_types.h
index 7c611e34293..99e60e817b9 100644
--- a/drivers/staging/csr/csr_wifi_fsm_types.h
+++ b/drivers/staging/csr/csr_wifi_fsm_types.h
@@ -219,7 +219,7 @@ typedef struct
  */
 typedef struct
 {
-    const CsrUint8              numEntries;
+    const u8              numEntries;
     const CsrBool               saveAll;
     const CsrWifiFsmEventEntry *eventEntryArray; /* array of transition function pointers for state */
 #ifdef CSR_LOG_ENABLE
diff --git a/drivers/staging/csr/csr_wifi_hip_card.h b/drivers/staging/csr/csr_wifi_hip_card.h
index 2ab47843bcc..c99a6065b5b 100644
--- a/drivers/staging/csr/csr_wifi_hip_card.h
+++ b/drivers/staging/csr/csr_wifi_hip_card.h
@@ -103,7 +103,7 @@ CsrResult card_wait_for_firmware_to_start(card_t *card, CsrUint32 *paddr);
 
 CsrResult unifi_dl_firmware(card_t *card, void *arg);
 CsrResult unifi_dl_patch(card_t *card, void *arg, CsrUint32 boot_ctrl);
-CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, CsrUint8 opcode);
+CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, u8 opcode);
 void* unifi_dl_fw_read_start(card_t *card, CsrInt8 is_fw);
 
 CsrResult unifi_coredump_handle_request(card_t *card);
diff --git a/drivers/staging/csr/csr_wifi_hip_card_sdio.c b/drivers/staging/csr/csr_wifi_hip_card_sdio.c
index 5a86ff90253..ef9c566b97f 100644
--- a/drivers/staging/csr/csr_wifi_hip_card_sdio.c
+++ b/drivers/staging/csr/csr_wifi_hip_card_sdio.c
@@ -139,7 +139,7 @@ card_t* unifi_alloc_card(CsrSdioFunction *sdio, void *ospriv)
     {
         CsrUint32 val = 0x01234567;
 
-        if (*((CsrUint8 *)&val) == 0x01)
+        if (*((u8 *)&val) == 0x01)
         {
             card->lsb = sizeof(void *) - 1;     /* BE */
         }
@@ -510,7 +510,7 @@ static CsrResult unifi_hip_init(card_t *card)
  * ---------------------------------------------------------------------------
  */
 static void _build_sdio_config_data(sdio_config_data_t *cfg_data,
-                                    const CsrUint8     *cfg_data_buf)
+                                    const u8     *cfg_data_buf)
 {
     CsrInt16 offset = 0;
 
@@ -603,7 +603,7 @@ static CsrResult card_hw_init(card_t *card)
     CsrUint16 finger_print;
     symbol_t slut;
     sdio_config_data_t *cfg_data;
-    CsrUint8 cfg_data_buf[SDIO_CONFIG_DATA_SIZE];
+    u8 cfg_data_buf[SDIO_CONFIG_DATA_SIZE];
     CsrResult r;
     void *dlpriv;
     CsrInt16 major, minor;
@@ -1002,7 +1002,7 @@ static CsrResult card_wait_for_unifi_to_reset(card_t *card)
 {
     CsrInt16 i;
     CsrResult r;
-    CsrUint8 io_enable;
+    u8 io_enable;
     CsrResult csrResult;
 
     func_enter();
@@ -1134,7 +1134,7 @@ static CsrResult card_wait_for_unifi_to_disable(card_t *card)
 {
     CsrInt16 i;
     CsrResult r;
-    CsrUint8 io_enable;
+    u8 io_enable;
     CsrResult csrResult;
 
     func_enter();
@@ -2006,7 +2006,7 @@ void unifi_free_card(card_t *card)
 static CsrResult card_init_slots(card_t *card)
 {
     CsrResult r;
-    CsrUint8 i;
+    u8 i;
 
     func_enter();
 
@@ -2170,7 +2170,7 @@ CsrResult unifi_remove_udi_hook(card_t *card, udi_func_t udi_fn)
 
 static void CardReassignDynamicReservation(card_t *card)
 {
-    CsrUint8 i;
+    u8 i;
 
     func_enter();
 
@@ -2352,7 +2352,7 @@ static void CardCheckDynamicReservation(card_t *card, unifi_TrafficQueue queue)
  */
 void CardClearFromHostDataSlot(card_t *card, const CsrInt16 slot)
 {
-    CsrUint8 queue = card->from_host_data[slot].queue;
+    u8 queue = card->from_host_data[slot].queue;
     const void *os_data_ptr = card->from_host_data[slot].bd.os_data_ptr;
 
     func_enter();
@@ -2419,7 +2419,7 @@ void CardClearFromHostDataSlot(card_t *card, const CsrInt16 slot)
  */
 void CardClearFromHostDataSlotWithoutFreeingBulkData(card_t *card, const CsrInt16 slot)
 {
-    CsrUint8 queue = card->from_host_data[slot].queue;
+    u8 queue = card->from_host_data[slot].queue;
 
     /* Initialise the from_host data slot so it can be re-used,
      * Set length field in from_host_data array to 0.
@@ -2538,7 +2538,7 @@ static CsrResult unifi_identify_hw(card_t *card)
      * Setup the chip helper so that we can access the registers (and
      * also tell what sub-type of HIP we should use).
      */
-    card->helper = ChipHelper_GetVersionSdio((CsrUint8)card->chip_id);
+    card->helper = ChipHelper_GetVersionSdio((u8)card->chip_id);
     if (!card->helper)
     {
         unifi_error(card->ospriv, "Null ChipHelper\n");
@@ -3121,13 +3121,13 @@ CsrResult CardGenInt(card_t *card)
     if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
     {
         r = sdio_write_f0(card, SDIO_CSR_FROM_HOST_SCRATCH0,
-                          (CsrUint8)card->unifi_interrupt_seq);
+                          (u8)card->unifi_interrupt_seq);
     }
     else
     {
         r = unifi_write_direct_8_or_16(card,
                                        ChipHelper_SHARED_IO_INTERRUPT(card->helper) * 2,
-                                       (CsrUint8)card->unifi_interrupt_seq);
+                                       (u8)card->unifi_interrupt_seq);
     }
     if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
     {
@@ -3165,7 +3165,7 @@ CsrResult CardGenInt(card_t *card)
 CsrResult CardEnableInt(card_t *card)
 {
     CsrResult r;
-    CsrUint8 int_enable;
+    u8 int_enable;
 
     r = sdio_read_f0(card, SDIO_INT_ENABLE, &int_enable);
     if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
@@ -3213,7 +3213,7 @@ CsrResult CardEnableInt(card_t *card)
 CsrResult CardDisableInt(card_t *card)
 {
     CsrResult r;
-    CsrUint8 int_enable;
+    u8 int_enable;
 
     r = sdio_read_f0(card, SDIO_INT_ENABLE, &int_enable);
     if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
@@ -3264,7 +3264,7 @@ CsrResult CardDisableInt(card_t *card)
 CsrResult CardPendingInt(card_t *card, CsrBool *pintr)
 {
     CsrResult r;
-    CsrUint8 pending;
+    u8 pending;
 
     *pintr = FALSE;
 
@@ -3364,7 +3364,7 @@ CsrResult CardClearInt(card_t *card)
 CsrResult CardIntEnabled(card_t *card, CsrBool *enabled)
 {
     CsrResult r;
-    CsrUint8 int_enable;
+    u8 int_enable;
 
     r = sdio_read_f0(card, SDIO_INT_ENABLE, &int_enable);
     if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
@@ -3403,7 +3403,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;
-    CsrUint8 *packed_sigptr, num_slots_required = 0;
+    u8 *packed_sigptr, num_slots_required = 0;
     bulk_data_desc_t *bulkdata = csptr->bulkdata;
     CsrInt16 h, nslots;
 
@@ -3704,7 +3704,7 @@ static void bootstrap_chip_hw(card_t *card)
 CsrResult unifi_card_stop_processor(card_t *card, enum unifi_dbg_processors_select which)
 {
     CsrResult r = CSR_RESULT_SUCCESS;
-    CsrUint8 status;
+    u8 status;
     CsrInt16 retry = 100;
 
     while (retry--)
@@ -3903,10 +3903,10 @@ CsrResult unifi_set_host_state(card_t *card, enum unifi_host_state state)
     static const CsrCharString *const states[] = {
         "AWAKE", "DROWSY", "TORPID"
     };
-    static const CsrUint8 state_csr_host_wakeup[] = {
+    static const u8 state_csr_host_wakeup[] = {
         1, 3, 0
     };
-    static const CsrUint8 state_io_abort[] = {
+    static const u8 state_io_abort[] = {
         0, 2, 3
     };
 
@@ -3922,7 +3922,7 @@ CsrResult unifi_set_host_state(card_t *card, enum unifi_host_state state)
     if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
     {
         r = sdio_write_f0(card, SDIO_CSR_HOST_WAKEUP,
-                          (CsrUint8)((card->function << 4) | state_csr_host_wakeup[state]));
+                          (u8)((card->function << 4) | state_csr_host_wakeup[state]));
     }
     else
     {
@@ -4034,7 +4034,7 @@ void unifi_card_info(card_t *card, card_info_t *card_info)
  */
 CsrResult unifi_check_io_status(card_t *card, CsrInt32 *status)
 {
-    CsrUint8 io_en;
+    u8 io_en;
     CsrResult r;
     CsrBool pending;
 
diff --git a/drivers/staging/csr/csr_wifi_hip_card_sdio.h b/drivers/staging/csr/csr_wifi_hip_card_sdio.h
index 4481d81eee4..2615169d426 100644
--- a/drivers/staging/csr/csr_wifi_hip_card_sdio.h
+++ b/drivers/staging/csr/csr_wifi_hip_card_sdio.h
@@ -246,7 +246,7 @@ typedef struct
  */
 typedef struct card_signal
 {
-    CsrUint8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
+    u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
 
     /* Length of the SIGNAL inside sigbuf */
     CsrUint16 signal_length;
@@ -421,7 +421,7 @@ struct card
     CsrUint16 chip_version;
 
     /* From the SDIO driver (probably 1) */
-    CsrUint8 function;
+    u8 function;
 
     /* This is sused to get the register addresses and things. */
     ChipDescript *helper;
@@ -448,11 +448,11 @@ struct card
     /* UDI callback for logging UniFi interactions */
     udi_func_t udi_hook;
 
-    CsrUint8 bh_reason_host;
-    CsrUint8 bh_reason_unifi;
+    u8 bh_reason_host;
+    u8 bh_reason_unifi;
 
     /* SDIO clock speed request from OS layer */
-    CsrUint8 request_max_clock;
+    u8 request_max_clock;
 
     /* Last SDIO clock frequency set */
     CsrUint32 sdio_clock_speed;
@@ -505,8 +505,8 @@ struct card
 #define UNIFI_FH_BUF_SIZE 1024
     struct sigbuf
     {
-        CsrUint8 *buf;     /* buffer area */
-        CsrUint8 *ptr;     /* current pos */
+        u8 *buf;     /* buffer area */
+        u8 *ptr;     /* current pos */
         CsrUint16 count;   /* signal count */
         CsrUint16 bufsize;
     } fh_buffer;
@@ -519,7 +519,7 @@ struct card
      * Flag to say we need to generate an interrupt at end of processing.
      */
     CsrUint32 unifi_interrupt_seq;
-    CsrUint8  generate_interrupt;
+    u8  generate_interrupt;
 
 
     /* Pointers to the bulk data slots */
@@ -560,7 +560,7 @@ struct card
     CsrUint32 sdio_bytes_read;
     CsrUint32 sdio_bytes_written;
 
-    CsrUint8 memory_resources_allocated;
+    u8 memory_resources_allocated;
 
     /* UniFi SDIO I/O Block size. */
     CsrUint16 sdio_io_block_size;
@@ -615,7 +615,7 @@ struct card
     CsrUint32 intmode;
 
 #ifdef UNIFI_DEBUG
-    CsrUint8 lsb;
+    u8 lsb;
 #endif
 
     /* Historic firmware panic codes */
@@ -671,10 +671,10 @@ CsrResult unifi_bulk_rw_noretry(card_t *card, CsrUint32 handle,
 #define UNIFI_SDIO_READ       0
 #define UNIFI_SDIO_WRITE      1
 
-CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 *pdata);
-CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 data);
-CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 *pdata);
-CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 data);
+CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 *pdata);
+CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 data);
+CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, u8 *pdata);
+CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, u8 data);
 
 CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, CsrUint16 *pdata);
 CsrResult unifi_read_direct32(card_t *card, CsrUint32 addr, CsrUint32 *pdata);
@@ -683,8 +683,8 @@ CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint1
 CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, CsrUint16 data);
 CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len);
 
-CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, CsrUint8 *pdata);
-CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, CsrUint8 data);
+CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, u8 *pdata);
+CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, u8 data);
 
 void unifi_read_panic(card_t *card);
 #ifdef CSR_PRE_ALLOC_NET_DATA
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 8fefbdfc715..52a6ed3ad7e 100644
--- a/drivers/staging/csr/csr_wifi_hip_card_sdio_intr.c
+++ b/drivers/staging/csr/csr_wifi_hip_card_sdio_intr.c
@@ -53,10 +53,10 @@ 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 CsrUint8 *cmdptr,
+                                           const u8 *cmdptr,
                                            CsrInt16 cmd, CsrUint16 len);
 static CsrResult process_clear_slot_command(card_t         *card,
-                                            const CsrUint8 *cmdptr);
+                                            const u8 *cmdptr);
 static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed);
 static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed);
 static void restart_packet_flow(card_t *card);
@@ -408,7 +408,7 @@ CsrResult unifi_bh(card_t *card, CsrUint32 *remaining)
          */
         if (card->host_state == UNIFI_HOST_STATE_DROWSY || card->host_state == UNIFI_HOST_STATE_TORPID)
         {
-            CsrUint8 reason_unifi;
+            u8 reason_unifi;
 
             /*
              * An interrupt may occur while or after we cache the reason.
@@ -1064,7 +1064,7 @@ static CsrResult update_to_host_signals_r(card_t *card, CsrInt16 pending)
 
     /* Update the count of signals read */
     r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 6,
-                            (CsrUint8)card->to_host_signals_r);
+                            (u8)card->to_host_signals_r);
     if (r != CSR_RESULT_SUCCESS)
     {
         unifi_error(card->ospriv, "Failed to update to-host signals read\n");
@@ -1098,7 +1098,7 @@ static CsrResult update_to_host_signals_r(card_t *card, CsrInt16 pending)
  *      None.
  * ---------------------------------------------------------------------------
  */
-static void read_unpack_cmd(const CsrUint8 *ptr, bulk_data_cmd_t *bulk_data_cmd)
+static void read_unpack_cmd(const u8 *ptr, bulk_data_cmd_t *bulk_data_cmd)
 {
     CsrInt16 index = 0;
     bulk_data_cmd->cmd_and_len = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
@@ -1147,7 +1147,7 @@ static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed)
 {
     CsrInt16 pending;
     CsrInt16 remaining;
-    CsrUint8 *bufptr;
+    u8 *bufptr;
     bulk_data_param_t data_ptrs;
     CsrInt16 cmd;
     CsrUint16 sig_len;
@@ -1512,8 +1512,8 @@ static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed)
     if (remaining > 0)
     {
         /* Use a safe copy because source and destination may overlap */
-        CsrUint8 *d = card->th_buffer.buf;
-        CsrUint8 *s = bufptr;
+        u8 *d = card->th_buffer.buf;
+        u8 *s = bufptr;
         CsrInt32 n = remaining;
         while (n--)
         {
@@ -1543,7 +1543,7 @@ static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed)
  *      0 on success, CSR error code on error
  * ---------------------------------------------------------------------------
  */
-static CsrResult process_clear_slot_command(card_t *card, const CsrUint8 *cmdptr)
+static CsrResult process_clear_slot_command(card_t *card, const u8 *cmdptr)
 {
     CsrUint16 data_slot;
     CsrInt16 slot;
@@ -1618,12 +1618,12 @@ static CsrResult process_clear_slot_command(card_t *card, const CsrUint8 *cmdptr
  *      CSR_RESULT_SUCCESS on success, CSR error code on error
  * ---------------------------------------------------------------------------
  */
-static CsrResult process_bulk_data_command(card_t *card, const CsrUint8 *cmdptr,
+static CsrResult process_bulk_data_command(card_t *card, const u8 *cmdptr,
                                            CsrInt16 cmd, CsrUint16 len)
 {
     bulk_data_desc_t *bdslot;
 #ifdef CSR_WIFI_ALIGNMENT_WORKAROUND
-    CsrUint8 *host_bulk_data_slot;
+    u8 *host_bulk_data_slot;
 #endif
     bulk_data_cmd_t bdcmd;
     CsrInt16 offset;
@@ -2032,7 +2032,7 @@ static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed)
         CsrInt16 i;
         CsrUint16 sig_chunks, total_length, free_chunks_in_fh_buffer;
         bulk_data_param_t bulkdata;
-        CsrUint8 *packed_sigptr;
+        u8 *packed_sigptr;
         CsrUint16 signal_length = 0;
 
         /* Retrieve the entry at the head of the queue */
@@ -2100,9 +2100,9 @@ static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed)
         /* Append packed signal to F-H buffer */
         total_length = sig_chunks * card->config_data.sig_frag_size;
 
-        card->fh_buffer.ptr[0] = (CsrUint8)(signal_length & 0xff);
+        card->fh_buffer.ptr[0] = (u8)(signal_length & 0xff);
         card->fh_buffer.ptr[1] =
-            (CsrUint8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
+            (u8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
 
         CsrMemCpy(card->fh_buffer.ptr + 2, packed_sigptr, signal_length);
         CsrMemSet(card->fh_buffer.ptr + 2 + signal_length, 0,
@@ -2273,7 +2273,7 @@ static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed)
         card_signal_t *csptr;
         CsrUint16 sig_chunks, total_length, free_chunks_in_fh_buffer;
         bulk_data_param_t bulkdata;
-        CsrUint8 *packed_sigptr;
+        u8 *packed_sigptr;
         CsrUint16 signal_length = 0;
 
         /* if this queue is empty go to next one. */
@@ -2378,9 +2378,9 @@ static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed)
         /* Append packed signal to F-H buffer */
         total_length = sig_chunks * card->config_data.sig_frag_size;
 
-        card->fh_buffer.ptr[0] = (CsrUint8)(signal_length & 0xff);
+        card->fh_buffer.ptr[0] = (u8)(signal_length & 0xff);
         card->fh_buffer.ptr[1] =
-            (CsrUint8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
+            (u8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
 
         CsrMemCpy(card->fh_buffer.ptr + 2, packed_sigptr, signal_length);
         CsrMemSet(card->fh_buffer.ptr + 2 + signal_length, 0,
@@ -2516,7 +2516,7 @@ static CsrResult flush_fh_buffer(card_t *card)
     card->from_host_signals_w =
         (card->from_host_signals_w + card->fh_buffer.count) % 128u;
     r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 0,
-                            (CsrUint8)card->from_host_signals_w);
+                            (u8)card->from_host_signals_w);
     if (r != CSR_RESULT_SUCCESS)
     {
         unifi_error(card->ospriv, "Failed to write fh signal count %u with error %d\n",
@@ -2556,7 +2556,7 @@ static CsrResult flush_fh_buffer(card_t *card)
  */
 static void restart_packet_flow(card_t *card)
 {
-    CsrUint8 q;
+    u8 q;
 
     /*
      * We only look at the fh_traffic_queue, because that is where packets from
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 8bc2d74e8d5..d5066ace787 100644
--- a/drivers/staging/csr/csr_wifi_hip_card_sdio_mem.c
+++ b/drivers/staging/csr/csr_wifi_hip_card_sdio_mem.c
@@ -53,7 +53,7 @@
  *      CSR_RESULT_FAILURE     an SDIO error occurred
  * ---------------------------------------------------------------------------
  */
-static CsrResult retrying_read8(card_t *card, CsrInt16 funcnum, CsrUint32 addr, CsrUint8 *pdata)
+static CsrResult retrying_read8(card_t *card, CsrInt16 funcnum, CsrUint32 addr, u8 *pdata)
 {
     CsrSdioFunction *sdio = card->sdio_if;
     CsrResult r = CSR_RESULT_SUCCESS;
@@ -128,7 +128,7 @@ static CsrResult retrying_read8(card_t *card, CsrInt16 funcnum, CsrUint32 addr,
 } /* retrying_read8() */
 
 
-static CsrResult retrying_write8(card_t *card, CsrInt16 funcnum, CsrUint32 addr, CsrUint8 data)
+static CsrResult retrying_write8(card_t *card, CsrInt16 funcnum, CsrUint32 addr, u8 data)
 {
     CsrSdioFunction *sdio = card->sdio_if;
     CsrResult r = CSR_RESULT_SUCCESS;
@@ -338,7 +338,7 @@ static CsrResult retrying_write16(card_t *card, CsrInt16 funcnum,
  *      CSR_RESULT_FAILURE     an SDIO error occurred
  * ---------------------------------------------------------------------------
  */
-CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, CsrUint8 *pdata)
+CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, u8 *pdata)
 {
 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
     card->cmd_prof.cmd52_f0_r_count++;
@@ -364,7 +364,7 @@ CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, CsrUint8 *pdata)
  *      CSR_RESULT_FAILURE     an SDIO error occurred
  * ---------------------------------------------------------------------------
  */
-CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, CsrUint8 data)
+CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, u8 data)
 {
 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
     card->cmd_prof.cmd52_f0_w_count++;
@@ -388,14 +388,14 @@ CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, CsrUint8 data)
  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 *pdata)
+CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, u8 *pdata)
 {
 #ifdef CSR_WIFI_TRANSPORT_CSPI
     CsrUint16 w;
     CsrResult r;
 
     r = retrying_read16(card, card->function, addr, &w);
-    *pdata = (CsrUint8)(w & 0xFF);
+    *pdata = (u8)(w & 0xFF);
     return r;
 #else
     return retrying_read8(card, card->function, addr, pdata);
@@ -423,7 +423,7 @@ CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 *pdat
  *      to memory until the preceding even address is written.
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 data)
+CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, u8 data)
 {
     if (addr & 1)
     {
@@ -568,12 +568,12 @@ static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pd
 {
     CsrResult r;
     CsrUint32 i;
-    CsrUint8 *cptr;
+    u8 *cptr;
     CsrUint16 w;
 
     *num = 0;
 
-    cptr = (CsrUint8 *)pdata;
+    cptr = (u8 *)pdata;
     for (i = 0; i < len; i += 2)
     {
         r = retrying_read16(card, card->function, addr, &w);
@@ -582,7 +582,7 @@ static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pd
             return r;
         }
 
-        *cptr++ = ((CsrUint8)w & 0xFF);
+        *cptr++ = ((u8)w & 0xFF);
         if ((m >= 0) && (((CsrInt8)w & 0xFF) == m))
         {
             break;
@@ -594,7 +594,7 @@ static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pd
             break;
         }
 
-        *cptr++ = ((CsrUint8)(w >> 8) & 0xFF);
+        *cptr++ = ((u8)(w >> 8) & 0xFF);
         if ((m >= 0) && (((CsrInt8)(w >> 8) & 0xFF) == m))
         {
             break;
@@ -603,7 +603,7 @@ static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pd
         addr += 2;
     }
 
-    *num = (CsrInt32)(cptr - (CsrUint8 *)pdata);
+    *num = (CsrInt32)(cptr - (u8 *)pdata);
     return CSR_RESULT_SUCCESS;
 }
 
@@ -667,10 +667,10 @@ CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint1
 CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len)
 {
     CsrResult r;
-    CsrUint8 *cptr;
+    u8 *cptr;
     CsrInt16 signed_len;
 
-    cptr = (CsrUint8 *)pdata;
+    cptr = (u8 *)pdata;
     signed_len = (CsrInt16)len;
     while (signed_len > 0)
     {
@@ -1022,7 +1022,7 @@ CsrResult unifi_set_proc_select(card_t *card, enum unifi_dbg_processors_select s
     {
         r = unifi_write_direct16(card,
                                  ChipHelper_DBG_HOST_PROC_SELECT(card->helper) * 2,
-                                 (CsrUint8)select);
+                                 (u8)select);
         if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
         {
             return r;
@@ -1059,7 +1059,7 @@ CsrResult unifi_set_proc_select(card_t *card, enum unifi_dbg_processors_select s
  * CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 *pdata)
+CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 *pdata)
 {
     CsrUint32 sdio_addr;
     CsrResult r;
@@ -1078,7 +1078,7 @@ CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 *pdata
 #endif
 #ifdef CSR_WIFI_TRANSPORT_CSPI
     r = retrying_read16(card, card->function, sdio_addr, &w);
-    *pdata = (CsrUint8)(w & 0xFF);
+    *pdata = (u8)(w & 0xFF);
     return r;
 #else
     return retrying_read8(card, card->function, sdio_addr, pdata);
@@ -1110,7 +1110,7 @@ CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 *pdata
  * write with the previously cached odd byte.
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 data)
+CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, u8 data)
 {
     CsrUint32 sdio_addr;
     CsrResult r;
@@ -1325,7 +1325,7 @@ CsrResult unifi_readnz(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint1
  */
 CsrInt32 unifi_read_shared_count(card_t *card, CsrUint32 addr)
 {
-    CsrUint8 b;
+    u8 b;
     /* I've increased this count, because I have seen cases where
      * there were three reads in a row with the top bit set.  I'm not
      * sure why this might have happened, but I can't see a problem
@@ -1400,7 +1400,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, CsrUint8 *pdata,
+                                   CsrUint32 addr, u8 *pdata,
                                    CsrUint16 count, CsrInt16 dir_is_write)
 {
     CsrResult csrResult;
@@ -1488,10 +1488,10 @@ CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle, void *pdata,
     CsrResult r = CSR_RESULT_SUCCESS; /* HIP error code */
     CsrInt16 retries = CMD53_RETRIES;
     CsrInt16 stat_retries;
-    CsrUint8 stat;
+    u8 stat;
     CsrInt16 dump_read;
 #ifdef UNIFI_DEBUG
-    CsrUint8 *pdata_lsb = ((CsrUint8 *)&pdata) + card->lsb;
+    u8 *pdata_lsb = ((u8 *)&pdata) + card->lsb;
 #endif
 #ifdef CSR_WIFI_MAKE_FAKE_CMD53_ERRORS
     static CsrInt16 fake_error;
@@ -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,
-                                      (CsrUint8 *)pdata, (CsrUint16)len,
+                                      (u8 *)pdata, (CsrUint16)len,
                                       direction);
         if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
         {
@@ -1591,7 +1591,7 @@ CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle, void *pdata,
 
         /* The transfer failed, rewind and try again */
         r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 8,
-                                (CsrUint8)(handle & 0xff));
+                                (u8)(handle & 0xff));
         if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
         {
             return r;
@@ -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,
-                                  (CsrUint8 *)pdata, (CsrUint16)len, direction);
+                                  (u8 *)pdata, (CsrUint16)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 a3148d87609..729df88f2b3 100644
--- a/drivers/staging/csr/csr_wifi_hip_chiphelper.c
+++ b/drivers/staging/csr/csr_wifi_hip_chiphelper.c
@@ -575,7 +575,7 @@ static const struct chip_device_desc_t *chip_ver_to_desc[] =
     &hyd_wlan_subsys_desc_v1
 };
 
-ChipDescript* ChipHelper_GetVersionSdio(CsrUint8 sdio_ver)
+ChipDescript* ChipHelper_GetVersionSdio(u8 sdio_ver)
 {
     CsrUint32 i;
 
diff --git a/drivers/staging/csr/csr_wifi_hip_chiphelper.h b/drivers/staging/csr/csr_wifi_hip_chiphelper.h
index 6166d558757..60dff8e92e0 100644
--- a/drivers/staging/csr/csr_wifi_hip_chiphelper.h
+++ b/drivers/staging/csr/csr_wifi_hip_chiphelper.h
@@ -173,7 +173,7 @@ ChipDescript* ChipHelper_GetVersionUniFi(CsrUint16 version);
 /* This gets the version from the SDIO device id.  This only
    gives quite a coarse grained version, so we should update once
    we hav access to the function N registers. */
-ChipDescript* ChipHelper_GetVersionSdio(CsrUint8 sdio_version);
+ChipDescript* ChipHelper_GetVersionSdio(u8 sdio_version);
 
 /* The chip is some sort of BlueCore.  If "age" is "pre_bc7" then
    "version" is what was read from FF9A.  If "age" is bc7_or_later
@@ -445,7 +445,7 @@ public:
     void GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81);
     void GetVersionUniFi(CsrUint16 version);
     void GetVersionBlueCore(chip_helper_bluecore_age age, CsrUint16 version);
-    void GetVersionSdio(CsrUint8 sdio_version);
+    void GetVersionSdio(u8 sdio_version);
 
     /* Helpers to build the definitions of the member functions. */
 #define CHIP_HELPER_DEF0_CPP_DEC(ret_type, name, info)    \
diff --git a/drivers/staging/csr/csr_wifi_hip_chiphelper_private.h b/drivers/staging/csr/csr_wifi_hip_chiphelper_private.h
index 7ab8173328c..c0e2f2afc68 100644
--- a/drivers/staging/csr/csr_wifi_hip_chiphelper_private.h
+++ b/drivers/staging/csr/csr_wifi_hip_chiphelper_private.h
@@ -143,7 +143,7 @@ struct chip_version_t
     CsrInt32  pre_bc7;
     CsrUint16 mask;
     CsrUint16 result;
-    CsrUint8  sdio;
+    u8  sdio;
 };
 
 struct chip_device_desc_t
diff --git a/drivers/staging/csr/csr_wifi_hip_conversions.h b/drivers/staging/csr/csr_wifi_hip_conversions.h
index 6a4647d5f91..212b9b7b105 100644
--- a/drivers/staging/csr/csr_wifi_hip_conversions.h
+++ b/drivers/staging/csr/csr_wifi_hip_conversions.h
@@ -69,9 +69,9 @@ extern "C" {
     CSR_GET_UINT16_FROM_LITTLE_ENDIAN(((_buf) + SIZEOF_SIGNAL_HEADER + UNIFI_MAX_DATA_REFERENCES * SIZEOF_DATAREF + 2))
 
 
-CsrInt32 get_packed_struct_size(const CsrUint8 *buf);
-CsrResult read_unpack_signal(const CsrUint8 *ptr, CSR_SIGNAL *sig);
-CsrResult write_pack(const CSR_SIGNAL *sig, CsrUint8 *ptr, CsrUint16 *sig_len);
+CsrInt32 get_packed_struct_size(const u8 *buf);
+CsrResult read_unpack_signal(const u8 *ptr, CSR_SIGNAL *sig);
+CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, CsrUint16 *sig_len);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_wifi_hip_download.c b/drivers/staging/csr/csr_wifi_hip_download.c
index 47178afe586..c43f589cb88 100644
--- a/drivers/staging/csr/csr_wifi_hip_download.c
+++ b/drivers/staging/csr/csr_wifi_hip_download.c
@@ -497,11 +497,11 @@ void* unifi_dl_fw_read_start(card_t *card, CsrInt8 is_fw)
  *      CSR_RESULT_SUCCESS on success, CSR error code on failure
  * ---------------------------------------------------------------------------
  */
-static CsrResult safe_read_shared_location(card_t *card, CsrUint32 address, CsrUint8 *pdata)
+static CsrResult safe_read_shared_location(card_t *card, CsrUint32 address, u8 *pdata)
 {
     CsrResult r;
     CsrUint16 limit = 1000;
-    CsrUint8 b, b2;
+    u8 b, b2;
 
     *pdata = 0;
 
@@ -559,7 +559,7 @@ static CsrResult safe_read_shared_location(card_t *card, CsrUint32 address, CsrU
 #define OPERATION_TIMEOUT_LOOPS (100)  /* when OPERATION_TIMEOUT_DELAY==1, (500) otherwise */
 #define OPERATION_TIMEOUT_DELAY 1      /* msec, or 200usecs */
 
-CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, CsrUint8 opcode)
+CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, u8 opcode)
 {
     CsrResult r;
     CsrInt16 op_retries;
@@ -580,7 +580,7 @@ CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, CsrUint8 opcode)
     r = CSR_RESULT_SUCCESS;
     while (1)
     {
-        CsrUint8 op;
+        u8 op;
 
         /*
          * Read the memory location until two successive reads give
@@ -658,7 +658,7 @@ static CsrResult send_ptdl_to_unifi(card_t *card, void *dlpriv,
                                     CsrUint32 op_addr)
 {
     CsrUint32 offset;
-    CsrUint8 *buf;
+    u8 *buf;
     CsrInt32 data_len;
     CsrUint32 write_len;
     CsrResult r;
diff --git a/drivers/staging/csr/csr_wifi_hip_packing.c b/drivers/staging/csr/csr_wifi_hip_packing.c
index 4e98da97666..e024a1fdd85 100644
--- a/drivers/staging/csr/csr_wifi_hip_packing.c
+++ b/drivers/staging/csr/csr_wifi_hip_packing.c
@@ -35,7 +35,7 @@
  *      This is useful for stepping past the signal to the object in the buffer.
  * ---------------------------------------------------------------------------
  */
-CsrInt32 get_packed_struct_size(const CsrUint8 *buf)
+CsrInt32 get_packed_struct_size(const u8 *buf)
 {
     CsrInt32 size = 0;
     CsrUint16 sig_id;
@@ -1148,7 +1148,7 @@ CsrInt32 get_packed_struct_size(const CsrUint8 *buf)
  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE if the ID of signal was not recognised.
  * ---------------------------------------------------------------------------
  */
-CsrResult read_unpack_signal(const CsrUint8 *ptr, CSR_SIGNAL *sig)
+CsrResult read_unpack_signal(const u8 *ptr, CSR_SIGNAL *sig)
 {
     CsrInt32 index = 0;
 
@@ -2984,7 +2984,7 @@ CsrResult read_unpack_signal(const CsrUint8 *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, CsrUint8 *ptr, CsrUint16 *sig_len)
+CsrResult write_pack(const CSR_SIGNAL *sig, u8 *ptr, CsrUint16 *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 624f3bb3712..96bf40e85fd 100644
--- a/drivers/staging/csr/csr_wifi_hip_send.c
+++ b/drivers/staging/csr/csr_wifi_hip_send.c
@@ -100,7 +100,7 @@ CSR_PRIORITY unifi_get_default_downgrade_priority(unifi_TrafficQueue queue)
  *      Calls unifi_pause_xmit() when the last slots are used.
  * ---------------------------------------------------------------------------
  */
-static CsrResult send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 siglen,
+static CsrResult send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
                              const bulk_data_param_t *bulkdata,
                              q_t *sigq, CsrUint32 priority_q, CsrUint32 run_bh)
 {
@@ -156,8 +156,8 @@ static CsrResult send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 sig
                     debug_print++;
                 }
                 /* Store the bulk data info in the soft queue. */
-                csptr->bulkdata[i].os_data_ptr = (CsrUint8 *)bulkdata->d[i].os_data_ptr;
-                csptr->bulkdata[i].os_net_buf_ptr = (CsrUint8 *)bulkdata->d[i].os_net_buf_ptr;
+                csptr->bulkdata[i].os_data_ptr = (u8 *)bulkdata->d[i].os_data_ptr;
+                csptr->bulkdata[i].os_net_buf_ptr = (u8 *)bulkdata->d[i].os_net_buf_ptr;
                 csptr->bulkdata[i].net_buf_length = bulkdata->d[i].net_buf_length;
                 csptr->bulkdata[i].data_length = datalen;
             }
@@ -170,7 +170,7 @@ static CsrResult send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 sig
 
     if (debug_print)
     {
-        const CsrUint8 *sig = sigptr;
+        const u8 *sig = sigptr;
 
         unifi_error(card->ospriv, "Signal(%d): %02x %02x %02x %02x %02x %02x %02x %02x"
                     " %02x %02x %02x %02x %02x %02x %02x %02x\n",
@@ -303,7 +303,7 @@ static CsrResult send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 sig
  *      to the device. Signals are constructed using the UniFi packed structures.
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 siglen,
+CsrResult unifi_send_signal(card_t *card, const u8 *sigptr, CsrUint32 siglen,
                             const bulk_data_param_t *bulkdata)
 {
     q_t *sig_soft_q;
@@ -383,7 +383,7 @@ CsrResult unifi_send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 sigl
  *  Notes:
  * ---------------------------------------------------------------------------
  */
-CsrResult unifi_send_resources_available(card_t *card, const CsrUint8 *sigptr)
+CsrResult unifi_send_resources_available(card_t *card, const u8 *sigptr)
 {
     q_t *sig_soft_q;
     CsrUint16 signal_id = GET_SIGNAL_ID(sigptr);
diff --git a/drivers/staging/csr/csr_wifi_hip_sigs.h b/drivers/staging/csr/csr_wifi_hip_sigs.h
index c94e2a48397..5d04c069b55 100644
--- a/drivers/staging/csr/csr_wifi_hip_sigs.h
+++ b/drivers/staging/csr/csr_wifi_hip_sigs.h
@@ -113,7 +113,7 @@ typedef enum CSR_LOADER_OPERATION
 
 typedef struct CSR_MAC_ADDRESS
 {
-    CsrUint8 x[6];
+    u8 x[6];
 } CSR_MACADDRESS;
 
 typedef enum CSR_MIB_STATUS
@@ -374,7 +374,7 @@ typedef enum CSR_SYMBOL_ID
 
 typedef struct CSR_TSF_TIME
 {
-    CsrUint8 x[8];
+    u8 x[8];
 } CSR_TSF_TIME;
 
 typedef CsrUint16 CSR_TIME_UNITS;
diff --git a/drivers/staging/csr/csr_wifi_hip_ta_sampling.c b/drivers/staging/csr/csr_wifi_hip_ta_sampling.c
index 7afcd3c90fc..7108cf064f5 100644
--- a/drivers/staging/csr/csr_wifi_hip_ta_sampling.c
+++ b/drivers/staging/csr/csr_wifi_hip_ta_sampling.c
@@ -72,7 +72,7 @@ enum ta_frame_identity
 #define snap_802_2                  0xAAAA0300
 #define oui_rfc1042                 0x00000000
 #define oui_8021h                   0x0000f800
-static const CsrUint8 aironet_snap[5] = { 0x00, 0x40, 0x96, 0x00, 0x00 };
+static const u8 aironet_snap[5] = { 0x00, 0x40, 0x96, 0x00, 0x00 };
 
 
 /*
@@ -93,8 +93,8 @@ static const CsrUint8 aironet_snap[5] = { 0x00, 0x40, 0x96, 0x00, 0x00 };
  */
 static enum ta_frame_identity ta_detect_protocol(card_t *card, CsrWifiRouterCtrlProtocolDirection direction,
                                                  const bulk_data_desc_t *data,
-                                                 const CsrUint8 *saddr,
-                                                 const CsrUint8 *sta_macaddr)
+                                                 const u8 *saddr,
+                                                 const u8 *sta_macaddr)
 {
     ta_data_t *tad = &card->ta_sampling;
     CsrUint16 proto;
@@ -138,7 +138,7 @@ static enum ta_frame_identity ta_detect_protocol(card_t *card, CsrWifiRouterCtrl
                 if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
                 {
                     ta_l4stats_t *ta_l4stats = &tad->ta_l4stats;
-                    CsrUint8 l4proto = data->os_data_ptr[TA_IP_TYPE_OFFSET];
+                    u8 l4proto = data->os_data_ptr[TA_IP_TYPE_OFFSET];
 
                     if (l4proto == TA_IP_TYPE_TCP)
                     {
@@ -344,8 +344,8 @@ void unifi_ta_sampling_init(card_t *card)
 void unifi_ta_sample(card_t                            *card,
                      CsrWifiRouterCtrlProtocolDirection direction,
                      const bulk_data_desc_t            *data,
-                     const CsrUint8                    *saddr,
-                     const CsrUint8                    *sta_macaddr,
+                     const u8                    *saddr,
+                     const u8                    *sta_macaddr,
                      CsrUint32                          timestamp,
                      CsrUint16                          rate)
 {
diff --git a/drivers/staging/csr/csr_wifi_hip_udi.c b/drivers/staging/csr/csr_wifi_hip_udi.c
index 2cf028108b1..b7c292c0d6a 100644
--- a/drivers/staging/csr/csr_wifi_hip_udi.c
+++ b/drivers/staging/csr/csr_wifi_hip_udi.c
@@ -55,7 +55,7 @@ CsrInt32 unifi_print_status(card_t *card, CsrCharString *str, CsrInt32 *remain)
         "AWAKE", "DROWSY", "TORPID"
     };
     #define SHARED_READ_RETRY_LIMIT 10
-    CsrUint8 b;
+    u8 b;
 #endif
 
     if (remaining <= 0)
diff --git a/drivers/staging/csr/csr_wifi_hip_unifi.h b/drivers/staging/csr/csr_wifi_hip_unifi.h
index 5f1c67b7c6e..62d77402b4e 100644
--- a/drivers/staging/csr/csr_wifi_hip_unifi.h
+++ b/drivers/staging/csr/csr_wifi_hip_unifi.h
@@ -139,7 +139,7 @@ typedef enum
  */
 typedef struct _bulk_data_desc
 {
-    const CsrUint8 *os_data_ptr;
+    const u8 *os_data_ptr;
     CsrUint32       data_length;
     const void     *os_net_buf_ptr;
     CsrUint32       net_buf_length;
@@ -324,7 +324,7 @@ void unifi_cancel_pending_signals(card_t *card);
  *
  * @ingroup upperedge
  */
-CsrResult unifi_send_signal(card_t *card, const CsrUint8 *sigptr,
+CsrResult unifi_send_signal(card_t *card, const u8 *sigptr,
                             CsrUint32 siglen,
                             const bulk_data_param_t *bulkdata);
 
@@ -343,7 +343,7 @@ CsrResult unifi_send_signal(card_t *card, const CsrUint8 *sigptr,
  *
  * @ingroup upperedge
  */
-CsrResult unifi_send_resources_available(card_t *card, const CsrUint8 *sigptr);
+CsrResult unifi_send_resources_available(card_t *card, const u8 *sigptr);
 
 /**
  *
@@ -511,8 +511,8 @@ CsrResult unifi_ta_configure(card_t                               *card,
 void unifi_ta_sample(card_t                            *card,
                      CsrWifiRouterCtrlProtocolDirection direction,
                      const bulk_data_desc_t            *data,
-                     const CsrUint8                    *saddr,
-                     const CsrUint8                    *sta_macaddr,
+                     const u8                    *saddr,
+                     const u8                    *sta_macaddr,
                      CsrUint32                          timestamp,
                      CsrUint16                          rate);
 
@@ -643,7 +643,7 @@ CsrResult unifi_run_bh(void *ospriv);
  * @ingroup upperedge
  */
 void unifi_receive_event(void *ospriv,
-                         CsrUint8 *sigdata, CsrUint32 siglen,
+                         u8 *sigdata, CsrUint32 siglen,
                          const bulk_data_param_t *bulkdata);
 
 #ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
diff --git a/drivers/staging/csr/csr_wifi_hip_unifi_udi.h b/drivers/staging/csr/csr_wifi_hip_unifi_udi.h
index 0873b7b998e..e69f5c75d22 100644
--- a/drivers/staging/csr/csr_wifi_hip_unifi_udi.h
+++ b/drivers/staging/csr/csr_wifi_hip_unifi_udi.h
@@ -37,7 +37,7 @@ enum udi_log_direction
     UDI_LOG_TO_HOST     = 0x0001
 };
 
-typedef void (*udi_func_t)(void *ospriv, CsrUint8 *sigdata,
+typedef void (*udi_func_t)(void *ospriv, u8 *sigdata,
                            CsrUint32 signal_len,
                            const bulk_data_param_t *bulkdata,
                            enum udi_log_direction dir);
diff --git a/drivers/staging/csr/csr_wifi_hip_xbv.c b/drivers/staging/csr/csr_wifi_hip_xbv.c
index 5aaec4da441..8bc79aab702 100644
--- a/drivers/staging/csr/csr_wifi_hip_xbv.c
+++ b/drivers/staging/csr/csr_wifi_hip_xbv.c
@@ -103,7 +103,7 @@ static CsrUint32 write_uint16(void *buf, const CsrUint32 offset,
 static CsrUint32 write_uint32(void *buf, const CsrUint32 offset,
                               const CsrUint32 val);
 static CsrUint32 write_bytes(void *buf, const CsrUint32 offset,
-                             const CsrUint8 *data, const CsrUint32 len);
+                             const u8 *data, const CsrUint32 len);
 static CsrUint32 write_tag(void *buf, const CsrUint32 offset,
                            const CsrCharString *tag_str);
 static CsrUint32 write_chunk(void *buf, const CsrUint32 offset,
@@ -489,7 +489,7 @@ static CsrInt32 xbv_push(xbv1_t *fwinfo, xbv_stack_t *stack,
 }
 
 
-static CsrUint32 xbv2uint(CsrUint8 *ptr, CsrInt32 len)
+static CsrUint32 xbv2uint(u8 *ptr, CsrInt32 len)
 {
     CsrUint32 u = 0;
     CsrInt16 i;
@@ -506,7 +506,7 @@ static CsrUint32 xbv2uint(CsrUint8 *ptr, CsrInt32 len)
 
 static CsrInt32 read_tag(card_t *card, ct_t *ct, tag_t *tag)
 {
-    CsrUint8 buf[8];
+    u8 buf[8];
     CsrInt32 n;
 
     n = (*ct->iread)(card->ospriv, ct->dlpriv, ct->ioffset, buf, 8);
@@ -549,7 +549,7 @@ static CsrInt32 read_bytes(card_t *card, ct_t *ct, void *buf, CsrUint32 len)
 
 static CsrInt32 read_uint(card_t *card, ct_t *ct, CsrUint32 *u, CsrUint32 len)
 {
-    CsrUint8 buf[4];
+    u8 buf[4];
 
     /* Integer cannot be more than 4 bytes */
     if (len > 4)
@@ -570,9 +570,9 @@ static CsrInt32 read_uint(card_t *card, ct_t *ct, CsrUint32 *u, CsrUint32 len)
 
 static CsrUint32 write_uint16(void *buf, const CsrUint32 offset, const CsrUint16 val)
 {
-    CsrUint8 *dst = (CsrUint8 *)buf + offset;
-    *dst++ = (CsrUint8)(val & 0xff); /* LSB first */
-    *dst = (CsrUint8)(val >> 8);
+    u8 *dst = (u8 *)buf + offset;
+    *dst++ = (u8)(val & 0xff); /* LSB first */
+    *dst = (u8)(val >> 8);
     return sizeof(CsrUint16);
 }
 
@@ -585,14 +585,14 @@ static CsrUint32 write_uint32(void *buf, const CsrUint32 offset, const CsrUint32
 }
 
 
-static CsrUint32 write_bytes(void *buf, const CsrUint32 offset, const CsrUint8 *data, const CsrUint32 len)
+static CsrUint32 write_bytes(void *buf, const CsrUint32 offset, const u8 *data, const CsrUint32 len)
 {
     CsrUint32 i;
-    CsrUint8 *dst = (CsrUint8 *)buf + offset;
+    u8 *dst = (u8 *)buf + offset;
 
     for (i = 0; i < len; i++)
     {
-        *dst++ = *((CsrUint8 *)data + i);
+        *dst++ = *((u8 *)data + i);
     }
     return len;
 }
@@ -600,7 +600,7 @@ static CsrUint32 write_bytes(void *buf, const CsrUint32 offset, const CsrUint8 *
 
 static CsrUint32 write_tag(void *buf, const CsrUint32 offset, const CsrCharString *tag_str)
 {
-    CsrUint8 *dst = (CsrUint8 *)buf + offset;
+    u8 *dst = (u8 *)buf + offset;
     CsrMemCpy(dst, tag_str, 4);
     return 4;
 }
@@ -619,7 +619,7 @@ static CsrUint32 write_chunk(void *buf, const CsrUint32 offset, const CsrCharStr
 static CsrUint16 calc_checksum(void *buf, const CsrUint32 offset, const CsrUint32 bytes_len)
 {
     CsrUint32 i;
-    CsrUint8 *src = (CsrUint8 *)buf + offset;
+    u8 *src = (u8 *)buf + offset;
     CsrUint16 sum = 0;
     CsrUint16 val;
 
diff --git a/drivers/staging/csr/csr_wifi_lib.h b/drivers/staging/csr/csr_wifi_lib.h
index 4c691fc8fdf..e1ef72b3e48 100644
--- a/drivers/staging/csr/csr_wifi_lib.h
+++ b/drivers/staging/csr/csr_wifi_lib.h
@@ -44,7 +44,7 @@ CsrWifiFsmEvent* CsrWifiEvent_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrS
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint8        value;
+    u8        value;
 } CsrWifiEventCsrUint8;
 
 /*----------------------------------------------------------------------------*
@@ -55,7 +55,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrWifiEventCsrUint8
  *
  *----------------------------------------------------------------------------*/
-CsrWifiEventCsrUint8* CsrWifiEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint8 value);
+CsrWifiEventCsrUint8* CsrWifiEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, u8 value);
 
 typedef struct
 {
@@ -93,7 +93,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       value16;
-    CsrUint8        value8;
+    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, CsrUint8 value8);
+CsrWifiEventCsrUint16CsrUint8* CsrWifiEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint16 value16, u8 value8);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_wifi_msgconv.h b/drivers/staging/csr/csr_wifi_msgconv.h
index d74e5953ad1..6029a21d573 100644
--- a/drivers/staging/csr/csr_wifi_msgconv.h
+++ b/drivers/staging/csr/csr_wifi_msgconv.h
@@ -21,37 +21,37 @@ extern "C" {
 #endif
 
 
-void CsrUint16SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint16 v);
-void CsrUint24SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v);
-void CsrUint32SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v);
+void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, CsrUint16 v);
+void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v);
+void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v);
 
-void CsrUint16DesBigEndian(CsrUint16 *v, CsrUint8 *buffer, CsrSize *offset);
-void CsrUint24DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset);
-void CsrUint32DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset);
+void CsrUint16DesBigEndian(CsrUint16 *v, u8 *buffer, CsrSize *offset);
+void CsrUint24DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset);
+void CsrUint32DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset);
 
-void CsrUint24Ser(CsrUint8 *ptr, CsrSize *len, CsrUint32 v);
-void CsrUint24Des(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset);
+void CsrUint24Ser(u8 *ptr, CsrSize *len, CsrUint32 v);
+void CsrUint24Des(CsrUint32 *v, u8 *buffer, CsrSize *offset);
 
 
 CsrSize CsrWifiEventSizeof(void *msg);
-CsrUint8* CsrWifiEventSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventDes(CsrUint8 *buffer, CsrSize length);
+u8* CsrWifiEventSer(u8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventDes(u8 *buffer, CsrSize length);
 
 CsrSize CsrWifiEventCsrUint8Sizeof(void *msg);
-CsrUint8* CsrWifiEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint8Des(CsrUint8 *buffer, CsrSize length);
+u8* CsrWifiEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint8Des(u8 *buffer, CsrSize length);
 
 CsrSize CsrWifiEventCsrUint16Sizeof(void *msg);
-CsrUint8* CsrWifiEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint16Des(CsrUint8 *buffer, CsrSize length);
+u8* CsrWifiEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint16Des(u8 *buffer, CsrSize length);
 
 CsrSize CsrWifiEventCsrUint32Sizeof(void *msg);
-CsrUint8* CsrWifiEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint32Des(CsrUint8 *buffer, CsrSize length);
+u8* CsrWifiEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint32Des(u8 *buffer, CsrSize length);
 
 CsrSize CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg);
-CsrUint8* CsrWifiEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
-void* CsrWifiEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length);
+u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length);
 
 #ifdef __cplusplus
 }
diff --git a/drivers/staging/csr/csr_wifi_nme_ap_lib.h b/drivers/staging/csr/csr_wifi_nme_ap_lib.h
index aa632d5dd0d..2deebdb3877 100644
--- a/drivers/staging/csr/csr_wifi_nme_ap_lib.h
+++ b/drivers/staging/csr/csr_wifi_nme_ap_lib.h
@@ -475,7 +475,7 @@ extern const CsrCharString *CsrWifiNmeApDownstreamPrimNames[CSR_WIFI_NME_AP_PRIM
     msg__->interfaceTag = (interfaceTag__); \
     msg__->selectedDevicePasswordId = (selectedDevicePasswordId__); \
     msg__->selectedConfigMethod = (selectedConfigMethod__); \
-    CsrMemCpy(msg__->pin, (pin__), sizeof(CsrUint8) * 8);
+    CsrMemCpy(msg__->pin, (pin__), sizeof(u8) * 8);
 
 #define CsrWifiNmeApWpsRegisterReqSendTo(dst__, src__, interfaceTag__, selectedDevicePasswordId__, selectedConfigMethod__, pin__) \
     { \
diff --git a/drivers/staging/csr/csr_wifi_nme_ap_prim.h b/drivers/staging/csr/csr_wifi_nme_ap_prim.h
index 561c2fdc379..5e08d53982f 100644
--- a/drivers/staging/csr/csr_wifi_nme_ap_prim.h
+++ b/drivers/staging/csr/csr_wifi_nme_ap_prim.h
@@ -53,7 +53,7 @@ typedef CsrPrim CsrWifiNmeApPrim;
                    - Use the specified passphrase as credential
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiNmeApPersCredentialType;
+typedef u8 CsrWifiNmeApPersCredentialType;
 #define CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK          ((CsrWifiNmeApPersCredentialType) 0x00)
 #define CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE   ((CsrWifiNmeApPersCredentialType) 0x01)
 
@@ -81,7 +81,7 @@ typedef struct
     CsrBool   apStrictGtkRekey;
     CsrUint16 apGmkTimeout;
     CsrUint16 apResponseTimeout;
-    CsrUint8  apRetransLimit;
+    u8  apRetransLimit;
 } CsrWifiNmeApConfig;
 
 /*******************************************************************************
@@ -225,7 +225,7 @@ typedef struct
     CsrUint16               interfaceTag;
     CsrWifiSmeWpsDpid       selectedDevicePasswordId;
     CsrWifiSmeWpsConfigType selectedConfigMethod;
-    CsrUint8                pin[8];
+    u8                pin[8];
 } CsrWifiNmeApWpsRegisterReq;
 
 /*******************************************************************************
@@ -259,9 +259,9 @@ typedef struct
     CsrBool                 cloakSsid;
     CsrWifiSsid             ssid;
     CsrWifiSmeRadioIF       ifIndex;
-    CsrUint8                channel;
+    u8                channel;
     CsrWifiNmeApCredentials apCredentials;
-    CsrUint8                maxConnections;
+    u8                maxConnections;
     CsrWifiSmeApP2pGoConfig p2pGoParam;
     CsrBool                 wpsEnabled;
 } CsrWifiNmeApStartReq;
diff --git a/drivers/staging/csr/csr_wifi_nme_ap_serialize.c b/drivers/staging/csr/csr_wifi_nme_ap_serialize.c
index 947f86ad29d..cdf33a68823 100644
--- a/drivers/staging/csr/csr_wifi_nme_ap_serialize.c
+++ b/drivers/staging/csr/csr_wifi_nme_ap_serialize.c
@@ -36,13 +36,13 @@ CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg)
     bufferSize += 1;  /* CsrBool primitive->apConfig.apStrictGtkRekey */
     bufferSize += 2;  /* CsrUint16 primitive->apConfig.apGmkTimeout */
     bufferSize += 2;  /* CsrUint16 primitive->apConfig.apResponseTimeout */
-    bufferSize += 1;  /* CsrUint8 primitive->apConfig.apRetransLimit */
+    bufferSize += 1;  /* u8 primitive->apConfig.apRetransLimit */
     bufferSize += 1;  /* CsrWifiSmeApPhySupportMask primitive->apMacConfig.phySupportedBitmap */
     bufferSize += 2;  /* CsrUint16 primitive->apMacConfig.beaconInterval */
-    bufferSize += 1;  /* CsrUint8 primitive->apMacConfig.dtimPeriod */
+    bufferSize += 1;  /* u8 primitive->apMacConfig.dtimPeriod */
     bufferSize += 2;  /* CsrUint16 primitive->apMacConfig.maxListenInterval */
-    bufferSize += 1;  /* CsrUint8 primitive->apMacConfig.supportedRatesCount */
-    bufferSize += 20; /* CsrUint8 primitive->apMacConfig.supportedRates[20] */
+    bufferSize += 1;  /* u8 primitive->apMacConfig.supportedRatesCount */
+    bufferSize += 20; /* u8 primitive->apMacConfig.supportedRates[20] */
     bufferSize += 1;  /* CsrWifiSmePreambleType primitive->apMacConfig.preamble */
     bufferSize += 1;  /* CsrBool primitive->apMacConfig.shortSlotTimeEnabled */
     bufferSize += 1;  /* CsrWifiSmeCtsProtectionType primitive->apMacConfig.ctsProtectionType */
@@ -51,9 +51,9 @@ CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg)
         CsrUint16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApParams[i2].cwMin */
-            bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApParams[i2].cwMax */
-            bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApParams[i2].aifs */
+            bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].cwMin */
+            bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].cwMax */
+            bufferSize += 1; /* u8 primitive->apMacConfig.wmmApParams[i2].aifs */
             bufferSize += 2; /* CsrUint16 primitive->apMacConfig.wmmApParams[i2].txopLimit */
             bufferSize += 1; /* CsrBool primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory */
         }
@@ -62,76 +62,76 @@ CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg)
         CsrUint16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApBcParams[i2].cwMin */
-            bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApBcParams[i2].cwMax */
-            bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApBcParams[i2].aifs */
+            bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].cwMin */
+            bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].cwMax */
+            bufferSize += 1; /* u8 primitive->apMacConfig.wmmApBcParams[i2].aifs */
             bufferSize += 2; /* CsrUint16 primitive->apMacConfig.wmmApBcParams[i2].txopLimit */
             bufferSize += 1; /* CsrBool primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory */
         }
     }
     bufferSize += 1;         /* CsrWifiSmeApAccessType primitive->apMacConfig.accessType */
-    bufferSize += 1;         /* CsrUint8 primitive->apMacConfig.macAddressListCount */
+    bufferSize += 1;         /* u8 primitive->apMacConfig.macAddressListCount */
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
         {
-            bufferSize += 6; /* CsrUint8 primitive->apMacConfig.macAddressList[i2].a[6] */
+            bufferSize += 6; /* u8 primitive->apMacConfig.macAddressList[i2].a[6] */
         }
     }
     bufferSize += 1;         /* CsrBool primitive->apMacConfig.apHtParams.greenfieldSupported */
     bufferSize += 1;         /* CsrBool primitive->apMacConfig.apHtParams.shortGi20MHz */
-    bufferSize += 1;         /* CsrUint8 primitive->apMacConfig.apHtParams.rxStbc */
+    bufferSize += 1;         /* u8 primitive->apMacConfig.apHtParams.rxStbc */
     bufferSize += 1;         /* CsrBool primitive->apMacConfig.apHtParams.rifsModeAllowed */
-    bufferSize += 1;         /* CsrUint8 primitive->apMacConfig.apHtParams.htProtection */
+    bufferSize += 1;         /* u8 primitive->apMacConfig.apHtParams.htProtection */
     bufferSize += 1;         /* CsrBool primitive->apMacConfig.apHtParams.dualCtsProtection */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiNmeApConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apGroupkeyTimeout);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apConfig.apStrictGtkRekey);
+    CsrUint8Ser(ptr, len, (u8) primitive->apConfig.apStrictGtkRekey);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apGmkTimeout);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apResponseTimeout);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apConfig.apRetransLimit);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.phySupportedBitmap);
+    CsrUint8Ser(ptr, len, (u8) primitive->apConfig.apRetransLimit);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.phySupportedBitmap);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.beaconInterval);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.dtimPeriod);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.dtimPeriod);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.maxListenInterval);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.supportedRatesCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.supportedRatesCount);
     CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.supportedRates, ((CsrUint16) (20)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.preamble);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.shortSlotTimeEnabled);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.ctsProtectionType);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.preamble);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.shortSlotTimeEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.ctsProtectionType);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmEnabled);
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].cwMin);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].cwMax);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].aifs);
+            CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].cwMin);
+            CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].cwMax);
+            CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].aifs);
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.wmmApParams[i2].txopLimit);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory);
+            CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory);
         }
     }
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].cwMin);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].cwMax);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].aifs);
+            CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].cwMin);
+            CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].cwMax);
+            CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].aifs);
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.wmmApBcParams[i2].txopLimit);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory);
+            CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory);
         }
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.accessType);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.macAddressListCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.accessType);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.macAddressListCount);
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
@@ -139,17 +139,17 @@ CsrUint8* CsrWifiNmeApConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
             CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.macAddressList[i2].a, ((CsrUint16) (6)));
         }
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.greenfieldSupported);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.shortGi20MHz);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.rxStbc);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.rifsModeAllowed);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.htProtection);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.dualCtsProtection);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.greenfieldSupported);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.shortGi20MHz);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.rxStbc);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.rifsModeAllowed);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.htProtection);
+    CsrUint8Ser(ptr, len, (u8) primitive->apMacConfig.apHtParams.dualCtsProtection);
     return(ptr);
 }
 
 
-void* CsrWifiNmeApConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApConfigSetReq));
     CsrSize offset;
@@ -157,44 +157,44 @@ void* CsrWifiNmeApConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->apConfig.apGroupkeyTimeout, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apConfig.apStrictGtkRekey, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apConfig.apStrictGtkRekey, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->apConfig.apGmkTimeout, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->apConfig.apResponseTimeout, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apConfig.apRetransLimit, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.phySupportedBitmap, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apConfig.apRetransLimit, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.phySupportedBitmap, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.beaconInterval, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.dtimPeriod, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.dtimPeriod, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.maxListenInterval, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.supportedRatesCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.supportedRatesCount, buffer, &offset);
     CsrMemCpyDes(primitive->apMacConfig.supportedRates, buffer, &offset, ((CsrUint16) (20)));
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.preamble, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.shortSlotTimeEnabled, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.ctsProtectionType, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.preamble, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.shortSlotTimeEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.ctsProtectionType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.wmmEnabled, buffer, &offset);
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].cwMin, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].cwMax, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].aifs, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].cwMin, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].cwMax, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].aifs, buffer, &offset);
             CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.wmmApParams[i2].txopLimit, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory, buffer, &offset);
         }
     }
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < 4; i2++)
         {
-            CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMin, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMax, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].aifs, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMin, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMax, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].aifs, buffer, &offset);
             CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.wmmApBcParams[i2].txopLimit, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory, buffer, &offset);
         }
     }
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.accessType, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.macAddressListCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.accessType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.macAddressListCount, buffer, &offset);
     primitive->apMacConfig.macAddressList = NULL;
     if (primitive->apMacConfig.macAddressListCount)
     {
@@ -207,12 +207,12 @@ void* CsrWifiNmeApConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
             CsrMemCpyDes(primitive->apMacConfig.macAddressList[i2].a, buffer, &offset, ((CsrUint16) (6)));
         }
     }
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.greenfieldSupported, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.shortGi20MHz, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.rxStbc, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.rifsModeAllowed, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.htProtection, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.dualCtsProtection, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.greenfieldSupported, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.shortGi20MHz, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.rxStbc, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.rifsModeAllowed, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.htProtection, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apMacConfig.apHtParams.dualCtsProtection, buffer, &offset);
 
     return primitive;
 }
@@ -234,12 +234,12 @@ CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiSmeWpsDpid primitive->selectedDevicePasswordId */
     bufferSize += 2; /* CsrWifiSmeWpsConfigType primitive->selectedConfigMethod */
-    bufferSize += 8; /* CsrUint8 primitive->pin[8] */
+    bufferSize += 8; /* u8 primitive->pin[8] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiNmeApWpsRegisterReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *)msg;
     *len = 0;
@@ -252,7 +252,7 @@ CsrUint8* CsrWifiNmeApWpsRegisterReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApWpsRegisterReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterReq));
     CsrSize offset;
@@ -277,15 +277,15 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
     bufferSize += 2;  /* CsrUint16 primitive->interfaceTag */
     bufferSize += 1;  /* CsrWifiSmeApType primitive->apType */
     bufferSize += 1;  /* CsrBool primitive->cloakSsid */
-    bufferSize += 32; /* CsrUint8 primitive->ssid.ssid[32] */
-    bufferSize += 1;  /* CsrUint8 primitive->ssid.length */
+    bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
+    bufferSize += 1;  /* u8 primitive->ssid.length */
     bufferSize += 1;  /* CsrWifiSmeRadioIF primitive->ifIndex */
-    bufferSize += 1;  /* CsrUint8 primitive->channel */
+    bufferSize += 1;  /* u8 primitive->channel */
     bufferSize += 1;  /* CsrWifiSmeApAuthType primitive->apCredentials.authType */
     switch (primitive->apCredentials.authType)
     {
         case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
-            bufferSize += 1; /* CsrUint8 primitive->apCredentials.nmeAuthType.openSystemEmpty.empty */
+            bufferSize += 1; /* u8 primitive->apCredentials.nmeAuthType.openSystemEmpty.empty */
             break;
         case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
             bufferSize += 1; /* CsrWifiSmeWepCredentialType primitive->apCredentials.nmeAuthType.authwep.wepKeyType */
@@ -293,19 +293,19 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
             {
                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
                     bufferSize += 1;  /* CsrWifiSmeWepAuthMode primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType */
-                    bufferSize += 1;  /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey */
-                    bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1[13] */
-                    bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2[13] */
-                    bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3[13] */
-                    bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4[13] */
+                    bufferSize += 1;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey */
+                    bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1[13] */
+                    bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2[13] */
+                    bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3[13] */
+                    bufferSize += 13; /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4[13] */
                     break;
                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
                     bufferSize += 1;  /* CsrWifiSmeWepAuthMode primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType */
-                    bufferSize += 1;  /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey */
-                    bufferSize += 5;  /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1[5] */
-                    bufferSize += 5;  /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2[5] */
-                    bufferSize += 5;  /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3[5] */
-                    bufferSize += 5;  /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4[5] */
+                    bufferSize += 1;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey */
+                    bufferSize += 5;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1[5] */
+                    bufferSize += 5;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2[5] */
+                    bufferSize += 5;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3[5] */
+                    bufferSize += 5;  /* u8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4[5] */
                     break;
                 default:
                     break;
@@ -320,7 +320,7 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
             {
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
                     bufferSize += 2;                                                                                                                                                                                                                      /* CsrUint16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode */
-                    bufferSize += 32;                                                                                                                                                                                                                     /* CsrUint8 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk[32] */
+                    bufferSize += 32;                                                                                                                                                                                                                     /* u8 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk[32] */
                     break;
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
                     bufferSize += 2;                                                                                                                                                                                                                      /* CsrUint16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode */
@@ -333,21 +333,21 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
         default:
             break;
     }
-    bufferSize += 1; /* CsrUint8 primitive->maxConnections */
+    bufferSize += 1; /* u8 primitive->maxConnections */
     bufferSize += 1; /* CsrWifiSmeP2pGroupCapabilityMask primitive->p2pGoParam.groupCapability */
-    bufferSize += 3; /* CsrUint8 primitive->p2pGoParam.operatingChanList.country[3] */
-    bufferSize += 1; /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryListCount */
+    bufferSize += 3; /* u8 primitive->p2pGoParam.operatingChanList.country[3] */
+    bufferSize += 1; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryListCount */
     {
         CsrUint16 i3;
         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
         {
-            bufferSize += 1;                                                                                  /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass */
-            bufferSize += 1;                                                                                  /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount */
-            bufferSize += primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount; /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel */
+            bufferSize += 1;                                                                                  /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass */
+            bufferSize += 1;                                                                                  /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount */
+            bufferSize += primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount; /* u8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel */
         }
     }
     bufferSize += 1;                                                                                          /* CsrBool primitive->p2pGoParam.opPsEnabled */
-    bufferSize += 1;                                                                                          /* CsrUint8 primitive->p2pGoParam.ctWindow */
+    bufferSize += 1;                                                                                          /* u8 primitive->p2pGoParam.ctWindow */
     bufferSize += 1;                                                                                          /* CsrWifiSmeP2pNoaConfigMethod primitive->p2pGoParam.noaConfigMethod */
     bufferSize += 1;                                                                                          /* CsrBool primitive->p2pGoParam.allowNoaWithNonP2pDevices */
     bufferSize += 1;                                                                                          /* CsrBool primitive->wpsEnabled */
@@ -355,39 +355,39 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiNmeApStartReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apType);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakSsid);
+    CsrUint8Ser(ptr, len, (u8) primitive->apType);
+    CsrUint8Ser(ptr, len, (u8) primitive->cloakSsid);
     CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid.length);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ifIndex);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->channel);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.authType);
+    CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
+    CsrUint8Ser(ptr, len, (u8) primitive->ifIndex);
+    CsrUint8Ser(ptr, len, (u8) primitive->channel);
+    CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.authType);
     switch (primitive->apCredentials.authType)
     {
         case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.openSystemEmpty.empty);
+            CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.openSystemEmpty.empty);
             break;
         case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepKeyType);
+            CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepKeyType);
             switch (primitive->apCredentials.nmeAuthType.authwep.wepKeyType)
             {
                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType);
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey);
+                    CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType);
+                    CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey);
                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, ((CsrUint16) (13)));
                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, ((CsrUint16) (13)));
                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, ((CsrUint16) (13)));
                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, ((CsrUint16) (13)));
                     break;
                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType);
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey);
+                    CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType);
+                    CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey);
                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, ((CsrUint16) (5)));
                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, ((CsrUint16) (5)));
                     CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, ((CsrUint16) (5)));
@@ -398,10 +398,10 @@ CsrUint8* CsrWifiNmeApStartReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
             }
             break;
         case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport);
+            CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport);
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities);
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase);
+            CsrUint8Ser(ptr, len, (u8) primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase);
             switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
             {
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
@@ -419,32 +419,32 @@ CsrUint8* CsrWifiNmeApStartReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
         default:
             break;
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->maxConnections);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.groupCapability);
+    CsrUint8Ser(ptr, len, (u8) primitive->maxConnections);
+    CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.groupCapability);
     CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.country, ((CsrUint16) (3)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.operatingChanList.channelEntryListCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryListCount);
     {
         CsrUint16 i3;
         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
         {
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
+            CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass);
+            CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
             if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
             {
                 CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, ((CsrUint16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
             }
         }
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.opPsEnabled);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.ctWindow);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.noaConfigMethod);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.allowNoaWithNonP2pDevices);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.opPsEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.ctWindow);
+    CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.noaConfigMethod);
+    CsrUint8Ser(ptr, len, (u8) primitive->p2pGoParam.allowNoaWithNonP2pDevices);
+    CsrUint8Ser(ptr, len, (u8) primitive->wpsEnabled);
     return(ptr);
 }
 
 
-void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartReq));
     CsrSize offset;
@@ -452,33 +452,33 @@ void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apType, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->cloakSsid, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->cloakSsid, buffer, &offset);
     CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->ssid.length, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ifIndex, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->channel, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apCredentials.authType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ifIndex, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->channel, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apCredentials.authType, buffer, &offset);
     switch (primitive->apCredentials.authType)
     {
         case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
-            CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.openSystemEmpty.empty, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.openSystemEmpty.empty, buffer, &offset);
             break;
         case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
-            CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepKeyType, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepKeyType, buffer, &offset);
             switch (primitive->apCredentials.nmeAuthType.authwep.wepKeyType)
             {
                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
-                    CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType, buffer, &offset);
-                    CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey, buffer, &offset);
                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, buffer, &offset, ((CsrUint16) (13)));
                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, buffer, &offset, ((CsrUint16) (13)));
                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, buffer, &offset, ((CsrUint16) (13)));
                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, buffer, &offset, ((CsrUint16) (13)));
                     break;
                 case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
-                    CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType, buffer, &offset);
-                    CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey, buffer, &offset);
                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, buffer, &offset, ((CsrUint16) (5)));
                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, buffer, &offset, ((CsrUint16) (5)));
                     CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, buffer, &offset, ((CsrUint16) (5)));
@@ -489,10 +489,10 @@ void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize length)
             }
             break;
         case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
-            CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport, buffer, &offset);
             CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities, buffer, &offset);
             CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase, buffer, &offset);
             switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
             {
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
@@ -510,10 +510,10 @@ void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize length)
         default:
             break;
     }
-    CsrUint8Des((CsrUint8 *) &primitive->maxConnections, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.groupCapability, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->maxConnections, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->p2pGoParam.groupCapability, buffer, &offset);
     CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.country, buffer, &offset, ((CsrUint16) (3)));
-    CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.operatingChanList.channelEntryListCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryListCount, buffer, &offset);
     primitive->p2pGoParam.operatingChanList.channelEntryList = NULL;
     if (primitive->p2pGoParam.operatingChanList.channelEntryListCount)
     {
@@ -523,11 +523,11 @@ void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize length)
         CsrUint16 i3;
         for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
         {
-            CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount, buffer, &offset);
             if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
             {
-                primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel = (CsrUint8 *)CsrPmemAlloc(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
+                primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel = (u8 *)CsrPmemAlloc(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
                 CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, buffer, &offset, ((CsrUint16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
             }
             else
@@ -536,11 +536,11 @@ void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize length)
             }
         }
     }
-    CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.opPsEnabled, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.ctWindow, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.noaConfigMethod, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.allowNoaWithNonP2pDevices, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->wpsEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->p2pGoParam.opPsEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->p2pGoParam.ctWindow, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->p2pGoParam.noaConfigMethod, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->p2pGoParam.allowNoaWithNonP2pDevices, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->wpsEnabled, buffer, &offset);
 
     return primitive;
 }
@@ -585,9 +585,9 @@ CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
         CsrUint16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
-            bufferSize += 1; /* CsrUint8 primitive->wmmApParams[i1].cwMin */
-            bufferSize += 1; /* CsrUint8 primitive->wmmApParams[i1].cwMax */
-            bufferSize += 1; /* CsrUint8 primitive->wmmApParams[i1].aifs */
+            bufferSize += 1; /* u8 primitive->wmmApParams[i1].cwMin */
+            bufferSize += 1; /* u8 primitive->wmmApParams[i1].cwMax */
+            bufferSize += 1; /* u8 primitive->wmmApParams[i1].aifs */
             bufferSize += 2; /* CsrUint16 primitive->wmmApParams[i1].txopLimit */
             bufferSize += 1; /* CsrBool primitive->wmmApParams[i1].admissionControlMandatory */
         }
@@ -596,9 +596,9 @@ CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
         CsrUint16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
-            bufferSize += 1; /* CsrUint8 primitive->wmmApBcParams[i1].cwMin */
-            bufferSize += 1; /* CsrUint8 primitive->wmmApBcParams[i1].cwMax */
-            bufferSize += 1; /* CsrUint8 primitive->wmmApBcParams[i1].aifs */
+            bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].cwMin */
+            bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].cwMax */
+            bufferSize += 1; /* u8 primitive->wmmApBcParams[i1].aifs */
             bufferSize += 2; /* CsrUint16 primitive->wmmApBcParams[i1].txopLimit */
             bufferSize += 1; /* CsrBool primitive->wmmApBcParams[i1].admissionControlMandatory */
         }
@@ -607,7 +607,7 @@ CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiNmeApWmmParamUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *)msg;
     *len = 0;
@@ -616,29 +616,29 @@ CsrUint8* CsrWifiNmeApWmmParamUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *ms
         CsrUint16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].cwMin);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].cwMax);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].aifs);
+            CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].cwMin);
+            CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].cwMax);
+            CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].aifs);
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->wmmApParams[i1].txopLimit);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].admissionControlMandatory);
+            CsrUint8Ser(ptr, len, (u8) primitive->wmmApParams[i1].admissionControlMandatory);
         }
     }
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].cwMin);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].cwMax);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].aifs);
+            CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].cwMin);
+            CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].cwMax);
+            CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].aifs);
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->wmmApBcParams[i1].txopLimit);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].admissionControlMandatory);
+            CsrUint8Ser(ptr, len, (u8) primitive->wmmApBcParams[i1].admissionControlMandatory);
         }
     }
     return(ptr);
 }
 
 
-void* CsrWifiNmeApWmmParamUpdateReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWmmParamUpdateReq));
     CsrSize offset;
@@ -649,22 +649,22 @@ void* CsrWifiNmeApWmmParamUpdateReqDes(CsrUint8 *buffer, CsrSize length)
         CsrUint16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
-            CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].cwMin, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].cwMax, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].aifs, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->wmmApParams[i1].cwMin, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->wmmApParams[i1].cwMax, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->wmmApParams[i1].aifs, buffer, &offset);
             CsrUint16Des((CsrUint16 *) &primitive->wmmApParams[i1].txopLimit, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].admissionControlMandatory, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->wmmApParams[i1].admissionControlMandatory, buffer, &offset);
         }
     }
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < 4; i1++)
         {
-            CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].cwMin, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].cwMax, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].aifs, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].cwMin, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].cwMax, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].aifs, buffer, &offset);
             CsrUint16Des((CsrUint16 *) &primitive->wmmApBcParams[i1].txopLimit, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].admissionControlMandatory, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->wmmApBcParams[i1].admissionControlMandatory, buffer, &offset);
         }
     }
 
@@ -678,25 +678,25 @@ CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 6; /* CsrUint8 primitive->staMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->staMacAddress.a[6] */
     bufferSize += 1; /* CsrBool primitive->keepBlocking */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiNmeApStaRemoveReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrMemCpySer(ptr, len, (const void *) primitive->staMacAddress.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->keepBlocking);
+    CsrUint8Ser(ptr, len, (u8) primitive->keepBlocking);
     return(ptr);
 }
 
 
-void* CsrWifiNmeApStaRemoveReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStaRemoveReq));
     CsrSize offset;
@@ -705,7 +705,7 @@ void* CsrWifiNmeApStaRemoveReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrMemCpyDes(primitive->staMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->keepBlocking, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->keepBlocking, buffer, &offset);
 
     return primitive;
 }
@@ -722,7 +722,7 @@ CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiNmeApWpsRegisterCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *)msg;
     *len = 0;
@@ -733,7 +733,7 @@ CsrUint8* CsrWifiNmeApWpsRegisterCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApWpsRegisterCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterCfm));
     CsrSize offset;
@@ -754,13 +754,13 @@ CsrSize CsrWifiNmeApStartCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 40) */
     bufferSize += 2;  /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;  /* CsrResult primitive->status */
-    bufferSize += 32; /* CsrUint8 primitive->ssid.ssid[32] */
-    bufferSize += 1;  /* CsrUint8 primitive->ssid.length */
+    bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
+    bufferSize += 1;  /* u8 primitive->ssid.length */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiNmeApStartCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *)msg;
     *len = 0;
@@ -768,12 +768,12 @@ CsrUint8* CsrWifiNmeApStartCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
     CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid.length);
+    CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
     return(ptr);
 }
 
 
-void* CsrWifiNmeApStartCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartCfm));
     CsrSize offset;
@@ -783,7 +783,7 @@ void* CsrWifiNmeApStartCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
     CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->ssid.length, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
 
     return primitive;
 }
@@ -800,7 +800,7 @@ CsrSize CsrWifiNmeApStopCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiNmeApStopCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *)msg;
     *len = 0;
@@ -811,7 +811,7 @@ CsrUint8* CsrWifiNmeApStopCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiNmeApStopCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopCfm));
     CsrSize offset;
@@ -837,19 +837,19 @@ CsrSize CsrWifiNmeApStopIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiNmeApStopIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->apType);
+    CsrUint8Ser(ptr, len, (u8) primitive->apType);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
     return(ptr);
 }
 
 
-void* CsrWifiNmeApStopIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopInd));
     CsrSize offset;
@@ -857,7 +857,7 @@ void* CsrWifiNmeApStopIndDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->apType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->apType, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
 
     return primitive;
@@ -871,26 +871,26 @@ CsrSize CsrWifiNmeApStationIndSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeMediaStatus primitive->mediaStatus */
-    bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
-    bufferSize += 6; /* CsrUint8 primitive->peerDeviceAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerDeviceAddress.a[6] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiNmeApStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->mediaStatus);
+    CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
     CsrMemCpySer(ptr, len, (const void *) primitive->peerDeviceAddress.a, ((CsrUint16) (6)));
     return(ptr);
 }
 
 
-void* CsrWifiNmeApStationIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiNmeApStationIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStationInd));
     CsrSize offset;
@@ -898,7 +898,7 @@ void* CsrWifiNmeApStationIndDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->mediaStatus, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
     CsrMemCpyDes(primitive->peerDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
 
diff --git a/drivers/staging/csr/csr_wifi_nme_ap_serialize.h b/drivers/staging/csr/csr_wifi_nme_ap_serialize.h
index d59abf981cd..563afb10a7d 100644
--- a/drivers/staging/csr/csr_wifi_nme_ap_serialize.h
+++ b/drivers/staging/csr/csr_wifi_nme_ap_serialize.h
@@ -32,18 +32,18 @@ extern "C" {
 
 extern void CsrWifiNmeApPfree(void *ptr);
 
-extern CsrUint8* CsrWifiNmeApConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg);
 extern void CsrWifiNmeApConfigSetReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiNmeApWpsRegisterReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApWpsRegisterReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg);
 #define CsrWifiNmeApWpsRegisterReqSerFree CsrWifiNmeApPfree
 
-extern CsrUint8* CsrWifiNmeApStartReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeApStartReqSizeof(void *msg);
 extern void CsrWifiNmeApStartReqSerFree(void *msg);
 
@@ -52,13 +52,13 @@ extern void CsrWifiNmeApStartReqSerFree(void *msg);
 #define CsrWifiNmeApStopReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiNmeApStopReqSerFree CsrWifiNmeApPfree
 
-extern CsrUint8* CsrWifiNmeApWmmParamUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApWmmParamUpdateReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg);
 #define CsrWifiNmeApWmmParamUpdateReqSerFree CsrWifiNmeApPfree
 
-extern CsrUint8* CsrWifiNmeApStaRemoveReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStaRemoveReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg);
 #define CsrWifiNmeApStaRemoveReqSerFree CsrWifiNmeApPfree
 
@@ -67,23 +67,23 @@ extern CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg);
 #define CsrWifiNmeApConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiNmeApConfigSetCfmSerFree CsrWifiNmeApPfree
 
-extern CsrUint8* CsrWifiNmeApWpsRegisterCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApWpsRegisterCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg);
 #define CsrWifiNmeApWpsRegisterCfmSerFree CsrWifiNmeApPfree
 
-extern CsrUint8* CsrWifiNmeApStartCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStartCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeApStartCfmSizeof(void *msg);
 #define CsrWifiNmeApStartCfmSerFree CsrWifiNmeApPfree
 
-extern CsrUint8* CsrWifiNmeApStopCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStopCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeApStopCfmSizeof(void *msg);
 #define CsrWifiNmeApStopCfmSerFree CsrWifiNmeApPfree
 
-extern CsrUint8* CsrWifiNmeApStopIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStopIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeApStopIndSizeof(void *msg);
 #define CsrWifiNmeApStopIndSerFree CsrWifiNmeApPfree
 
@@ -92,8 +92,8 @@ extern CsrSize CsrWifiNmeApStopIndSizeof(void *msg);
 #define CsrWifiNmeApWmmParamUpdateCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiNmeApWmmParamUpdateCfmSerFree CsrWifiNmeApPfree
 
-extern CsrUint8* CsrWifiNmeApStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeApStationIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStationIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeApStationIndSizeof(void *msg);
 #define CsrWifiNmeApStationIndSerFree CsrWifiNmeApPfree
 
diff --git a/drivers/staging/csr/csr_wifi_nme_lib.h b/drivers/staging/csr/csr_wifi_nme_lib.h
index 897afbf1466..d7d3c03c1f3 100644
--- a/drivers/staging/csr/csr_wifi_nme_lib.h
+++ b/drivers/staging/csr/csr_wifi_nme_lib.h
@@ -790,8 +790,8 @@ extern const CsrCharString *CsrWifiNmeDownstreamPrimNames[CSR_WIFI_NME_PRIM_DOWN
 #define CsrWifiNmeSimUmtsAuthIndCreate(msg__, dst__, src__, rand__, autn__) \
     msg__ = (CsrWifiNmeSimUmtsAuthInd *) CsrPmemAlloc(sizeof(CsrWifiNmeSimUmtsAuthInd)); \
     CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_SIM_UMTS_AUTH_IND, dst__, src__); \
-    CsrMemCpy(msg__->rand, (rand__), sizeof(CsrUint8) * 16); \
-    CsrMemCpy(msg__->autn, (autn__), sizeof(CsrUint8) * 16);
+    CsrMemCpy(msg__->rand, (rand__), sizeof(u8) * 16); \
+    CsrMemCpy(msg__->autn, (autn__), sizeof(u8) * 16);
 
 #define CsrWifiNmeSimUmtsAuthIndSendTo(dst__, src__, rand__, autn__) \
     { \
@@ -839,11 +839,11 @@ extern const CsrCharString *CsrWifiNmeDownstreamPrimNames[CSR_WIFI_NME_PRIM_DOWN
     CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_SIM_UMTS_AUTH_RES, dst__, src__); \
     msg__->status = (status__); \
     msg__->result = (result__); \
-    CsrMemCpy(msg__->umtsCipherKey, (umtsCipherKey__), sizeof(CsrUint8) * 16); \
-    CsrMemCpy(msg__->umtsIntegrityKey, (umtsIntegrityKey__), sizeof(CsrUint8) * 16); \
+    CsrMemCpy(msg__->umtsCipherKey, (umtsCipherKey__), sizeof(u8) * 16); \
+    CsrMemCpy(msg__->umtsIntegrityKey, (umtsIntegrityKey__), sizeof(u8) * 16); \
     msg__->resParameterLength = (resParameterLength__); \
     msg__->resParameter = (resParameter__); \
-    CsrMemCpy(msg__->auts, (auts__), sizeof(CsrUint8) * 14);
+    CsrMemCpy(msg__->auts, (auts__), sizeof(u8) * 14);
 
 #define CsrWifiNmeSimUmtsAuthResSendTo(dst__, src__, status__, result__, umtsCipherKey__, umtsIntegrityKey__, resParameterLength__, resParameter__, auts__) \
     { \
@@ -1034,7 +1034,7 @@ extern const CsrCharString *CsrWifiNmeDownstreamPrimNames[CSR_WIFI_NME_PRIM_DOWN
     msg__ = (CsrWifiNmeWpsReq *) CsrPmemAlloc(sizeof(CsrWifiNmeWpsReq)); \
     CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_WPS_REQ, dst__, src__); \
     msg__->interfaceTag = (interfaceTag__); \
-    CsrMemCpy(msg__->pin, (pin__), sizeof(CsrUint8) * 8); \
+    CsrMemCpy(msg__->pin, (pin__), sizeof(u8) * 8); \
     msg__->ssid = (ssid__); \
     msg__->bssid = (bssid__);
 
diff --git a/drivers/staging/csr/csr_wifi_nme_prim.h b/drivers/staging/csr/csr_wifi_nme_prim.h
index 4d77d2f450c..79187bab81c 100644
--- a/drivers/staging/csr/csr_wifi_nme_prim.h
+++ b/drivers/staging/csr/csr_wifi_nme_prim.h
@@ -101,7 +101,7 @@ typedef CsrUint16 CsrWifiNmeAuthMode;
                    - P2P mode of operation.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiNmeBssType;
+typedef u8 CsrWifiNmeBssType;
 #define CSR_WIFI_NME_BSS_TYPE_INFRASTRUCTURE   ((CsrWifiNmeBssType) 0x00)
 #define CSR_WIFI_NME_BSS_TYPE_ADHOC            ((CsrWifiNmeBssType) 0x01)
 #define CSR_WIFI_NME_BSS_TYPE_RESERVED         ((CsrWifiNmeBssType) 0x02)
@@ -120,7 +120,7 @@ typedef CsrUint8 CsrWifiNmeBssType;
     CSR_WIFI_NME_CCX_OPTION_CCKM - CCX option cckm is set.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiNmeCcxOptionsMask;
+typedef u8 CsrWifiNmeCcxOptionsMask;
 #define CSR_WIFI_NME_CCX_OPTION_NONE   ((CsrWifiNmeCcxOptionsMask) 0x00)
 #define CSR_WIFI_NME_CCX_OPTION_CCKM   ((CsrWifiNmeCcxOptionsMask) 0x01)
 
@@ -137,7 +137,7 @@ typedef CsrUint8 CsrWifiNmeCcxOptionsMask;
     CSR_WIFI_PIN_ENTRY_ENTER_PIN   -
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiNmeConfigAction;
+typedef u8 CsrWifiNmeConfigAction;
 #define CSR_WIFI_PIN_ENTRY_PUSH_BUTTON   ((CsrWifiNmeConfigAction) 0x00)
 #define CSR_WIFI_PIN_ENTRY_DISPLAY_PIN   ((CsrWifiNmeConfigAction) 0x01)
 #define CSR_WIFI_PIN_ENTRY_ENTER_PIN     ((CsrWifiNmeConfigAction) 0x02)
@@ -163,7 +163,7 @@ typedef CsrUint8 CsrWifiNmeConfigAction;
                    - NME is in the process of disconnecting.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiNmeConnectionStatus;
+typedef u8 CsrWifiNmeConnectionStatus;
 #define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_DISCONNECTED     ((CsrWifiNmeConnectionStatus) 0x00)
 #define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_CONNECTING       ((CsrWifiNmeConnectionStatus) 0x01)
 #define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_AUTHENTICATING   ((CsrWifiNmeConnectionStatus) 0x02)
@@ -363,7 +363,7 @@ typedef CsrUint32 CsrWifiNmeIndications;
                    - Unknown Security Error.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiNmeSecError;
+typedef u8 CsrWifiNmeSecError;
 #define CSR_WIFI_NME_SEC_ERROR_SEC_ERROR_UNKNOWN   ((CsrWifiNmeSecError) 0x00)
 
 /*******************************************************************************
@@ -384,7 +384,7 @@ typedef CsrUint8 CsrWifiNmeSecError;
                                       UMTS and GSM authentications.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiNmeSimCardType;
+typedef u8 CsrWifiNmeSimCardType;
 #define CSR_WIFI_NME_SIM_CARD_TYPE_2G     ((CsrWifiNmeSimCardType) 0x01)
 #define CSR_WIFI_NME_SIM_CARD_TYPE_3G     ((CsrWifiNmeSimCardType) 0x02)
 #define CSR_WIFI_NME_SIM_CARD_TYPE_2G3G   ((CsrWifiNmeSimCardType) 0x03)
@@ -413,7 +413,7 @@ typedef CsrUint8 CsrWifiNmeSimCardType;
                      aborted.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiNmeUmtsAuthResult;
+typedef u8 CsrWifiNmeUmtsAuthResult;
 #define CSR_WIFI_NME_UMTS_AUTH_RESULT_SUCCESS     ((CsrWifiNmeUmtsAuthResult) 0x00)
 #define CSR_WIFI_NME_UMTS_AUTH_RESULT_SYNC_FAIL   ((CsrWifiNmeUmtsAuthResult) 0x01)
 #define CSR_WIFI_NME_UMTS_AUTH_RESULT_REJECT      ((CsrWifiNmeUmtsAuthResult) 0x02)
@@ -449,7 +449,7 @@ typedef CsrUint8 CsrWifiNmeUmtsAuthResult;
                    - WMM AP may deliver a maximum of 6 buffered frames per USP.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiNmeWmmQosInfo;
+typedef u8 CsrWifiNmeWmmQosInfo;
 #define CSR_WIFI_NME_WMM_QOS_INFO_AC_MAX_SP_ALL    ((CsrWifiNmeWmmQosInfo) 0x00)
 #define CSR_WIFI_NME_WMM_QOS_INFO_AC_VO            ((CsrWifiNmeWmmQosInfo) 0x01)
 #define CSR_WIFI_NME_WMM_QOS_INFO_AC_VI            ((CsrWifiNmeWmmQosInfo) 0x02)
@@ -511,7 +511,7 @@ typedef CsrUint32 CsrWifiNmeNmeIndicationsMask;
     Mask type for use with the values defined by CsrWifiNmeWmmQosInfo
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiNmeWmmQosInfoMask;
+typedef u8 CsrWifiNmeWmmQosInfoMask;
 
 
 /*******************************************************************************
@@ -528,7 +528,7 @@ typedef CsrUint8 CsrWifiNmeWmmQosInfoMask;
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8 empty;
+    u8 empty;
 } CsrWifiNmeEmpty;
 
 /*******************************************************************************
@@ -566,7 +566,7 @@ typedef struct
 typedef struct
 {
     CsrUint16 encryptionMode;
-    CsrUint8  psk[32];
+    u8  psk[32];
 } CsrWifiNmePsk;
 
 /*******************************************************************************
@@ -595,11 +595,11 @@ typedef struct
 typedef struct
 {
     CsrUint32 certificateLength;
-    CsrUint8 *certificate;
+    u8 *certificate;
     CsrUint16 privateKeyLength;
-    CsrUint8 *privateKey;
+    u8 *privateKey;
     CsrUint32 caCertificateLength;
-    CsrUint8 *caCertificate;
+    u8 *caCertificate;
 } CsrWifiNmeWapiCredentials;
 
 /*******************************************************************************
@@ -712,17 +712,17 @@ typedef struct
     CsrCharString           *userPassword;
     CsrCharString           *authServerUserIdentity;
     CsrUint32                clientCertificateLength;
-    CsrUint8                *clientCertificate;
+    u8                *clientCertificate;
     CsrUint32                certificateAuthorityCertificateLength;
-    CsrUint8                *certificateAuthorityCertificate;
+    u8                *certificateAuthorityCertificate;
     CsrUint16                privateKeyLength;
-    CsrUint8                *privateKey;
+    u8                *privateKey;
     CsrCharString           *privateKeyPassword;
     CsrUint32                sessionLength;
-    CsrUint8                *session;
+    u8                *session;
     CsrBool                  allowPacProvisioning;
     CsrUint32                pacLength;
-    CsrUint8                *pac;
+    u8                *pac;
     CsrCharString           *pacPassword;
 } CsrWifiNmeEapCredentials;
 
@@ -744,7 +744,7 @@ typedef struct
 {
     CsrWifiMacAddress                p2pDeviceId;
     CsrWifiSmeP2pGroupCapabilityMask groupCapabilityMask;
-    CsrUint8                         groupOwnerIntent;
+    u8                         groupOwnerIntent;
 } CsrWifiNmePeerConfig;
 
 /*******************************************************************************
@@ -790,11 +790,11 @@ typedef struct
 typedef struct
 {
     CsrWifiSmeAuthModeMask wepAuthType;
-    CsrUint8               selectedWepKey;
-    CsrUint8               key1[13];
-    CsrUint8               key2[13];
-    CsrUint8               key3[13];
-    CsrUint8               key4[13];
+    u8               selectedWepKey;
+    u8               key1[13];
+    u8               key2[13];
+    u8               key3[13];
+    u8               key4[13];
 } CsrWifiNmeWep128Keys;
 
 /*******************************************************************************
@@ -819,11 +819,11 @@ typedef struct
 typedef struct
 {
     CsrWifiSmeAuthModeMask wepAuthType;
-    CsrUint8               selectedWepKey;
-    CsrUint8               key1[5];
-    CsrUint8               key2[5];
-    CsrUint8               key3[5];
-    CsrUint8               key4[5];
+    u8               selectedWepKey;
+    u8               key1[5];
+    u8               key2[5];
+    u8               key3[5];
+    u8               key4[5];
 } CsrWifiNmeWep64Keys;
 
 /*******************************************************************************
@@ -894,8 +894,8 @@ typedef struct
     CsrWifiNmeProfileIdentity profileIdentity;
     CsrWifiNmeWmmQosInfoMask  wmmQosInfoMask;
     CsrWifiNmeBssType         bssType;
-    CsrUint8                  channelNo;
-    CsrUint8                  ccxOptionsMask;
+    u8                  channelNo;
+    u8                  ccxOptionsMask;
     CsrBool                   cloakedSsid;
     CsrWifiNmeCredentials     credentials;
 } CsrWifiNmeProfile;
@@ -1036,7 +1036,7 @@ typedef struct
 {
     CsrWifiFsmEvent            common;
     CsrUint16                  interfaceTag;
-    CsrUint8                   profileIdentitysCount;
+    u8                   profileIdentitysCount;
     CsrWifiNmeProfileIdentity *profileIdentitys;
 } CsrWifiNmeProfileOrderSetReq;
 
@@ -1088,7 +1088,7 @@ typedef struct
 {
     CsrWifiFsmEvent   common;
     CsrUint16         interfaceTag;
-    CsrUint8          pin[8];
+    u8          pin[8];
     CsrWifiSsid       ssid;
     CsrWifiMacAddress bssid;
 } CsrWifiNmeWpsReq;
@@ -1186,10 +1186,10 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrResult       status;
-    CsrUint8        kcsLength;
-    CsrUint8       *kcs;
-    CsrUint8        sresLength;
-    CsrUint8       *sres;
+    u8        kcsLength;
+    u8       *kcs;
+    u8        sresLength;
+    u8       *sres;
 } CsrWifiNmeSimGsmAuthRes;
 
 /*******************************************************************************
@@ -1229,11 +1229,11 @@ typedef struct
     CsrWifiFsmEvent          common;
     CsrResult                status;
     CsrWifiNmeUmtsAuthResult result;
-    CsrUint8                 umtsCipherKey[16];
-    CsrUint8                 umtsIntegrityKey[16];
-    CsrUint8                 resParameterLength;
-    CsrUint8                *resParameter;
-    CsrUint8                 auts[14];
+    u8                 umtsCipherKey[16];
+    u8                 umtsIntegrityKey[16];
+    u8                 resParameterLength;
+    u8                *resParameter;
+    u8                 auts[14];
 } CsrWifiNmeSimUmtsAuthRes;
 
 /*******************************************************************************
@@ -1399,7 +1399,7 @@ typedef struct
     CsrWifiFsmEvent           common;
     CsrUint16                 interfaceTag;
     CsrResult                 status;
-    CsrUint8                  connectAttemptsCount;
+    u8                  connectAttemptsCount;
     CsrWifiNmeConnectAttempt *connectAttempts;
 } CsrWifiNmeProfileConnectCfm;
 
@@ -1532,7 +1532,7 @@ typedef struct
 {
     CsrWifiFsmEvent           common;
     CsrUint16                 interfaceTag;
-    CsrUint8                  connectAttemptsCount;
+    u8                  connectAttemptsCount;
     CsrWifiNmeConnectAttempt *connectAttempts;
 } CsrWifiNmeProfileDisconnectInd;
 
@@ -1585,8 +1585,8 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint8        randsLength;
-    CsrUint8       *rands;
+    u8        randsLength;
+    u8       *rands;
 } CsrWifiNmeSimGsmAuthInd;
 
 /*******************************************************************************
@@ -1614,8 +1614,8 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrUint8        rand[16];
-    CsrUint8        autn[16];
+    u8        rand[16];
+    u8        autn[16];
 } CsrWifiNmeSimUmtsAuthInd;
 
 /*******************************************************************************
diff --git a/drivers/staging/csr/csr_wifi_nme_serialize.h b/drivers/staging/csr/csr_wifi_nme_serialize.h
index aeca9c83dc7..ecc56744078 100644
--- a/drivers/staging/csr/csr_wifi_nme_serialize.h
+++ b/drivers/staging/csr/csr_wifi_nme_serialize.h
@@ -29,13 +29,13 @@ extern "C" {
 
 extern void CsrWifiNmePfree(void *ptr);
 
-extern CsrUint8* CsrWifiNmeProfileSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeProfileSetReqSizeof(void *msg);
 extern void CsrWifiNmeProfileSetReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiNmeProfileDeleteReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileDeleteReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileDeleteReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileDeleteReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeProfileDeleteReqSizeof(void *msg);
 #define CsrWifiNmeProfileDeleteReqSerFree CsrWifiNmePfree
 
@@ -44,18 +44,18 @@ extern CsrSize CsrWifiNmeProfileDeleteReqSizeof(void *msg);
 #define CsrWifiNmeProfileDeleteAllReqSizeof CsrWifiEventSizeof
 #define CsrWifiNmeProfileDeleteAllReqSerFree CsrWifiNmePfree
 
-extern CsrUint8* CsrWifiNmeProfileOrderSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileOrderSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileOrderSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileOrderSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeProfileOrderSetReqSizeof(void *msg);
 extern void CsrWifiNmeProfileOrderSetReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiNmeProfileConnectReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileConnectReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileConnectReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileConnectReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeProfileConnectReqSizeof(void *msg);
 #define CsrWifiNmeProfileConnectReqSerFree CsrWifiNmePfree
 
-extern CsrUint8* CsrWifiNmeWpsReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeWpsReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeWpsReqSizeof(void *msg);
 #define CsrWifiNmeWpsReqSerFree CsrWifiNmePfree
 
@@ -69,23 +69,23 @@ extern CsrSize CsrWifiNmeWpsReqSizeof(void *msg);
 #define CsrWifiNmeConnectionStatusGetReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiNmeConnectionStatusGetReqSerFree CsrWifiNmePfree
 
-extern CsrUint8* CsrWifiNmeSimImsiGetResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimImsiGetResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeSimImsiGetResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimImsiGetResDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeSimImsiGetResSizeof(void *msg);
 extern void CsrWifiNmeSimImsiGetResSerFree(void *msg);
 
-extern CsrUint8* CsrWifiNmeSimGsmAuthResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimGsmAuthResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeSimGsmAuthResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimGsmAuthResDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeSimGsmAuthResSizeof(void *msg);
 extern void CsrWifiNmeSimGsmAuthResSerFree(void *msg);
 
-extern CsrUint8* CsrWifiNmeSimUmtsAuthResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimUmtsAuthResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeSimUmtsAuthResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimUmtsAuthResDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeSimUmtsAuthResSizeof(void *msg);
 extern void CsrWifiNmeSimUmtsAuthResSerFree(void *msg);
 
-extern CsrUint8* CsrWifiNmeWpsConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeWpsConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeWpsConfigSetReqSizeof(void *msg);
 extern void CsrWifiNmeWpsConfigSetReqSerFree(void *msg);
 
@@ -109,38 +109,38 @@ extern void CsrWifiNmeWpsConfigSetReqSerFree(void *msg);
 #define CsrWifiNmeProfileDeleteAllCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiNmeProfileDeleteAllCfmSerFree CsrWifiNmePfree
 
-extern CsrUint8* CsrWifiNmeProfileOrderSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileOrderSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileOrderSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileOrderSetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeProfileOrderSetCfmSizeof(void *msg);
 #define CsrWifiNmeProfileOrderSetCfmSerFree CsrWifiNmePfree
 
-extern CsrUint8* CsrWifiNmeProfileConnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileConnectCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileConnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileConnectCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeProfileConnectCfmSizeof(void *msg);
 extern void CsrWifiNmeProfileConnectCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiNmeWpsCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeWpsCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeWpsCfmSizeof(void *msg);
 extern void CsrWifiNmeWpsCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiNmeWpsCancelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeWpsCancelCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeWpsCancelCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsCancelCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeWpsCancelCfmSizeof(void *msg);
 #define CsrWifiNmeWpsCancelCfmSerFree CsrWifiNmePfree
 
-extern CsrUint8* CsrWifiNmeConnectionStatusGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeConnectionStatusGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeConnectionStatusGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeConnectionStatusGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeConnectionStatusGetCfmSizeof(void *msg);
 #define CsrWifiNmeConnectionStatusGetCfmSerFree CsrWifiNmePfree
 
-extern CsrUint8* CsrWifiNmeProfileUpdateIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileUpdateIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileUpdateIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileUpdateIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeProfileUpdateIndSizeof(void *msg);
 extern void CsrWifiNmeProfileUpdateIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiNmeProfileDisconnectIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeProfileDisconnectIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeProfileDisconnectIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileDisconnectIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeProfileDisconnectIndSizeof(void *msg);
 extern void CsrWifiNmeProfileDisconnectIndSerFree(void *msg);
 
@@ -149,13 +149,13 @@ extern void CsrWifiNmeProfileDisconnectIndSerFree(void *msg);
 #define CsrWifiNmeSimImsiGetIndSizeof CsrWifiEventSizeof
 #define CsrWifiNmeSimImsiGetIndSerFree CsrWifiNmePfree
 
-extern CsrUint8* CsrWifiNmeSimGsmAuthIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimGsmAuthIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeSimGsmAuthIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimGsmAuthIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeSimGsmAuthIndSizeof(void *msg);
 extern void CsrWifiNmeSimGsmAuthIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiNmeSimUmtsAuthIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiNmeSimUmtsAuthIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiNmeSimUmtsAuthIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimUmtsAuthIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiNmeSimUmtsAuthIndSizeof(void *msg);
 #define CsrWifiNmeSimUmtsAuthIndSerFree CsrWifiNmePfree
 
diff --git a/drivers/staging/csr/csr_wifi_private_common.h b/drivers/staging/csr/csr_wifi_private_common.h
index b1d12397bd6..878b23b6577 100644
--- a/drivers/staging/csr/csr_wifi_private_common.h
+++ b/drivers/staging/csr/csr_wifi_private_common.h
@@ -72,7 +72,7 @@ extern "C" {
 
 
 /* Common structure for NME and SME to maintain Interface mode*/
-typedef CsrUint8 CsrWifiInterfaceMode;
+typedef u8 CsrWifiInterfaceMode;
 #define  CSR_WIFI_MODE_NONE                             ((CsrWifiInterfaceMode) 0xFF)
 #define  CSR_WIFI_MODE_STA                              ((CsrWifiInterfaceMode) 0x00)
 #define  CSR_WIFI_MODE_AP                               ((CsrWifiInterfaceMode) 0x01)
diff --git a/drivers/staging/csr/csr_wifi_router_ctrl_prim.h b/drivers/staging/csr/csr_wifi_router_ctrl_prim.h
index 810482a8fba..acf10ef1e77 100644
--- a/drivers/staging/csr/csr_wifi_router_ctrl_prim.h
+++ b/drivers/staging/csr/csr_wifi_router_ctrl_prim.h
@@ -28,14 +28,14 @@ extern "C" {
 
 typedef CsrPrim CsrWifiRouterCtrlPrim;
 
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteWrite)(CsrUint8 func, CsrUint32 address, CsrUint8 data);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteRead)(CsrUint8 func, CsrUint32 address, CsrUint8 *pdata);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioFirmwareDownload)(CsrUint32 length, const CsrUint8 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteWrite)(u8 func, CsrUint32 address, u8 data);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteRead)(u8 func, CsrUint32 address, u8 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioFirmwareDownload)(CsrUint32 length, const u8 *pdata);
 typedef CsrResult (*CsrWifiRouterCtrlRawSdioReset)(void);
 typedef CsrResult (*CsrWifiRouterCtrlRawSdioCoreDumpPrepare)(CsrBool suspendSme);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteBlockRead)(CsrUint8 func, CsrUint32 address, CsrUint8 *pdata, CsrUint32 length);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpRead16)(CsrUint8 func, CsrUint32 address, CsrUint16 *pdata);
-typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(CsrUint8 func, CsrUint32 address, CsrUint16 data);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteBlockRead)(u8 func, CsrUint32 address, u8 *pdata, CsrUint32 length);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpRead16)(u8 func, CsrUint32 address, CsrUint16 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(u8 func, CsrUint32 address, CsrUint16 data);
 
 /*******************************************************************************
 
@@ -51,7 +51,7 @@ typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(CsrUint8 func, CsrUint32
                    -
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlBlockAckRole;
+typedef u8 CsrWifiRouterCtrlBlockAckRole;
 #define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ORIGINATOR   ((CsrWifiRouterCtrlBlockAckRole) 0x00)
 #define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_RECIPIENT    ((CsrWifiRouterCtrlBlockAckRole) 0x01)
 
@@ -71,7 +71,7 @@ typedef CsrUint8 CsrWifiRouterCtrlBlockAckRole;
                    -
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlControlIndication;
+typedef u8 CsrWifiRouterCtrlControlIndication;
 #define CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_ERROR            ((CsrWifiRouterCtrlControlIndication) 0x01)
 #define CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_EXIT             ((CsrWifiRouterCtrlControlIndication) 0x02)
 #define CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_USER_REQUESTED   ((CsrWifiRouterCtrlControlIndication) 0x03)
@@ -94,7 +94,7 @@ typedef CsrUint8 CsrWifiRouterCtrlControlIndication;
                    -
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlListAction;
+typedef u8 CsrWifiRouterCtrlListAction;
 #define CSR_WIFI_ROUTER_CTRL_LIST_ACTION_GET      ((CsrWifiRouterCtrlListAction) 0x00)
 #define CSR_WIFI_ROUTER_CTRL_LIST_ACTION_ADD      ((CsrWifiRouterCtrlListAction) 0x01)
 #define CSR_WIFI_ROUTER_CTRL_LIST_ACTION_REMOVE   ((CsrWifiRouterCtrlListAction) 0x02)
@@ -132,7 +132,7 @@ typedef CsrUint16 CsrWifiRouterCtrlLowPowerMode;
                    -
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlMediaStatus;
+typedef u8 CsrWifiRouterCtrlMediaStatus;
 #define CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_CONNECTED      ((CsrWifiRouterCtrlMediaStatus) 0x00)
 #define CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_DISCONNECTED   ((CsrWifiRouterCtrlMediaStatus) 0x01)
 
@@ -155,7 +155,7 @@ typedef CsrUint8 CsrWifiRouterCtrlMediaStatus;
     CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI  -
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlMode;
+typedef u8 CsrWifiRouterCtrlMode;
 #define CSR_WIFI_ROUTER_CTRL_MODE_NONE      ((CsrWifiRouterCtrlMode) 0x00)
 #define CSR_WIFI_ROUTER_CTRL_MODE_IBSS      ((CsrWifiRouterCtrlMode) 0x01)
 #define CSR_WIFI_ROUTER_CTRL_MODE_STA       ((CsrWifiRouterCtrlMode) 0x02)
@@ -182,7 +182,7 @@ typedef CsrUint8 CsrWifiRouterCtrlMode;
                    -
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlPeerStatus;
+typedef u8 CsrWifiRouterCtrlPeerStatus;
 #define CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE       ((CsrWifiRouterCtrlPeerStatus) 0x00)
 #define CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE   ((CsrWifiRouterCtrlPeerStatus) 0x01)
 #define CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED           ((CsrWifiRouterCtrlPeerStatus) 0x02)
@@ -314,7 +314,7 @@ typedef CsrUint16 CsrWifiRouterCtrlQoSControl;
                    -
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlQueueConfig;
+typedef u8 CsrWifiRouterCtrlQueueConfig;
 #define CSR_WIFI_ROUTER_CTRL_QUEUE_BE_ENABLE   ((CsrWifiRouterCtrlQueueConfig) 0x01)
 #define CSR_WIFI_ROUTER_CTRL_QUEUE_BK_ENABLE   ((CsrWifiRouterCtrlQueueConfig) 0x02)
 #define CSR_WIFI_ROUTER_CTRL_QUEUE_VI_ENABLE   ((CsrWifiRouterCtrlQueueConfig) 0x04)
@@ -395,7 +395,7 @@ typedef CsrUint16 CsrWifiRouterCtrlTrafficPacketType;
                    -
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlTrafficType;
+typedef u8 CsrWifiRouterCtrlTrafficType;
 #define CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_OCCASIONAL   ((CsrWifiRouterCtrlTrafficType) 0x00)
 #define CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_BURSTY       ((CsrWifiRouterCtrlTrafficType) 0x01)
 #define CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_PERIODIC     ((CsrWifiRouterCtrlTrafficType) 0x02)
@@ -431,7 +431,7 @@ typedef CsrUint16 CsrWifiRouterCtrlPowersaveTypeMask;
     Mask type for use with the values defined by CsrWifiRouterCtrlQueueConfig
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlQueueConfigMask;
+typedef u8 CsrWifiRouterCtrlQueueConfigMask;
 /*******************************************************************************
 
   NAME
@@ -449,7 +449,7 @@ typedef CsrUint16 CsrWifiRouterCtrlRequestorInfo;
   DESCRIPTION
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterCtrlTrafficStreamId;
+typedef u8 CsrWifiRouterCtrlTrafficStreamId;
 
 
 /*******************************************************************************
@@ -490,7 +490,7 @@ typedef struct
 {
     CsrBool                            wmmOrQosEnabled;
     CsrWifiRouterCtrlPowersaveTypeMask powersaveMode;
-    CsrUint8                           maxSpLength;
+    u8                           maxSpLength;
     CsrUint16                          listenIntervalInTus;
 } CsrWifiRouterCtrlStaInfo;
 
@@ -511,7 +511,7 @@ typedef struct
 typedef struct
 {
     CsrUint32 etherType;
-    CsrUint8  ipType;
+    u8  ipType;
     CsrUint32 udpSourcePort;
     CsrUint32 udpDestPort;
 } CsrWifiRouterCtrlTrafficFilter;
@@ -539,7 +539,7 @@ typedef struct
     CsrUint32 txFramesNum;
     CsrUint32 rxBytesCount;
     CsrUint32 txBytesCount;
-    CsrUint8  intervals[11];
+    u8  intervals[11];
 } CsrWifiRouterCtrlTrafficStats;
 
 /*******************************************************************************
@@ -709,11 +709,11 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       mlmeCommandLength;
-    CsrUint8       *mlmeCommand;
+    u8       *mlmeCommand;
     CsrUint16       dataRef1Length;
-    CsrUint8       *dataRef1;
+    u8       *dataRef1;
     CsrUint16       dataRef2Length;
-    CsrUint8       *dataRef2;
+    u8       *dataRef2;
 } CsrWifiRouterCtrlHipReq;
 
 /*******************************************************************************
@@ -762,7 +762,7 @@ typedef struct
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrResult                      status;
     CsrWifiRouterCtrlListAction    action;
-    CsrUint8                       getAddressesCount;
+    u8                       getAddressesCount;
     CsrWifiMacAddress             *getAddresses;
 } CsrWifiRouterCtrlMulticastAddressRes;
 
@@ -859,7 +859,7 @@ typedef struct
     CsrUint16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrUint16                      tclasLength;
-    CsrUint8                      *tclas;
+    u8                      *tclas;
 } CsrWifiRouterCtrlTclasAddReq;
 
 /*******************************************************************************
@@ -939,7 +939,7 @@ typedef struct
     CsrUint16                      interfaceTag;
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrUint16                      tclasLength;
-    CsrUint8                      *tclas;
+    u8                      *tclas;
 } CsrWifiRouterCtrlTclasDelReq;
 
 /*******************************************************************************
@@ -1045,7 +1045,7 @@ typedef struct
     CsrWifiFsmEvent                common;
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrUint32                      dataLength;
-    CsrUint8                      *data;
+    u8                      *data;
 } CsrWifiRouterCtrlWifiOnReq;
 
 /*******************************************************************************
@@ -1299,9 +1299,9 @@ typedef struct
     CsrWifiFsmEvent common;
     CsrUint16       interfaceTag;
     CsrUint16       signalLength;
-    CsrUint8       *signal;
+    u8       *signal;
     CsrUint16       dataLength;
-    CsrUint8       *data;
+    u8       *data;
 } CsrWifiRouterCtrlWapiRxPktReq;
 
 /*******************************************************************************
@@ -1321,7 +1321,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       interfaceTag;
-    CsrUint8        status;
+    u8        status;
 } CsrWifiRouterCtrlWapiMulticastFilterReq;
 
 /*******************************************************************************
@@ -1341,7 +1341,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       interfaceTag;
-    CsrUint8        status;
+    u8        status;
 } CsrWifiRouterCtrlWapiUnicastFilterReq;
 
 /*******************************************************************************
@@ -1363,7 +1363,7 @@ typedef struct
     CsrWifiFsmEvent common;
     CsrUint16       interfaceTag;
     CsrUint16       dataLength;
-    CsrUint8       *data;
+    u8       *data;
 } CsrWifiRouterCtrlWapiUnicastTxPktReq;
 
 /*******************************************************************************
@@ -1408,11 +1408,11 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       mlmeCommandLength;
-    CsrUint8       *mlmeCommand;
+    u8       *mlmeCommand;
     CsrUint16       dataRef1Length;
-    CsrUint8       *dataRef1;
+    u8       *dataRef1;
     CsrUint16       dataRef2Length;
-    CsrUint8       *dataRef2;
+    u8       *dataRef2;
 } CsrWifiRouterCtrlHipInd;
 
 /*******************************************************************************
@@ -1437,7 +1437,7 @@ typedef struct
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrUint16                      interfaceTag;
     CsrWifiRouterCtrlListAction    action;
-    CsrUint8                       setAddressesCount;
+    u8                       setAddressesCount;
     CsrWifiMacAddress             *setAddresses;
 } CsrWifiRouterCtrlMulticastAddressInd;
 
@@ -2060,9 +2060,9 @@ typedef struct
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrUint16                      interfaceTag;
     CsrUint16                      signalLength;
-    CsrUint8                      *signal;
+    u8                      *signal;
     CsrUint16                      dataLength;
-    CsrUint8                      *data;
+    u8                      *data;
 } CsrWifiRouterCtrlWapiRxMicCheckInd;
 
 /*******************************************************************************
@@ -2110,7 +2110,7 @@ typedef struct
     CsrWifiRouterCtrlRequestorInfo clientData;
     CsrUint16                      interfaceTag;
     CsrUint16                      dataLength;
-    CsrUint8                      *data;
+    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 3239c9bad18..7aa96e365f2 100644
--- a/drivers/staging/csr/csr_wifi_router_ctrl_serialize.c
+++ b/drivers/staging/csr/csr_wifi_router_ctrl_serialize.c
@@ -36,19 +36,19 @@ CsrSize CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlConfigurePowerModeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->mode);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->wakeHost);
+    CsrUint8Ser(ptr, len, (u8) primitive->wakeHost);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlConfigurePowerModeReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlConfigurePowerModeReq));
     CsrSize offset;
@@ -57,7 +57,7 @@ void* CsrWifiRouterCtrlConfigurePowerModeReqDes(CsrUint8 *buffer, CsrSize length
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->mode, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->wakeHost, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->wakeHost, buffer, &offset);
 
     return primitive;
 }
@@ -70,16 +70,16 @@ CsrSize CsrWifiRouterCtrlHipReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
     bufferSize += 2;                            /* CsrUint16 primitive->mlmeCommandLength */
-    bufferSize += primitive->mlmeCommandLength; /* CsrUint8 primitive->mlmeCommand */
+    bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
     bufferSize += 2;                            /* CsrUint16 primitive->dataRef1Length */
-    bufferSize += primitive->dataRef1Length;    /* CsrUint8 primitive->dataRef1 */
+    bufferSize += primitive->dataRef1Length;    /* u8 primitive->dataRef1 */
     bufferSize += 2;                            /* CsrUint16 primitive->dataRef2Length */
-    bufferSize += primitive->dataRef2Length;    /* CsrUint8 primitive->dataRef2 */
+    bufferSize += primitive->dataRef2Length;    /* u8 primitive->dataRef2 */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlHipReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *)msg;
     *len = 0;
@@ -103,7 +103,7 @@ CsrUint8* CsrWifiRouterCtrlHipReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlHipReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlHipReq));
     CsrSize offset;
@@ -113,7 +113,7 @@ void* CsrWifiRouterCtrlHipReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->mlmeCommandLength, buffer, &offset);
     if (primitive->mlmeCommandLength)
     {
-        primitive->mlmeCommand = (CsrUint8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
+        primitive->mlmeCommand = (u8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
         CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((CsrUint16) (primitive->mlmeCommandLength)));
     }
     else
@@ -123,7 +123,7 @@ void* CsrWifiRouterCtrlHipReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->dataRef1Length, buffer, &offset);
     if (primitive->dataRef1Length)
     {
-        primitive->dataRef1 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef1Length);
+        primitive->dataRef1 = (u8 *)CsrPmemAlloc(primitive->dataRef1Length);
         CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((CsrUint16) (primitive->dataRef1Length)));
     }
     else
@@ -133,7 +133,7 @@ void* CsrWifiRouterCtrlHipReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->dataRef2Length, buffer, &offset);
     if (primitive->dataRef2Length)
     {
-        primitive->dataRef2 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef2Length);
+        primitive->dataRef2 = (u8 *)CsrPmemAlloc(primitive->dataRef2Length);
         CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((CsrUint16) (primitive->dataRef2Length)));
     }
     else
@@ -167,19 +167,19 @@ CsrSize CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlMediaStatusReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->mediaStatus);
+    CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlMediaStatusReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMediaStatusReq));
     CsrSize offset;
@@ -188,7 +188,7 @@ void* CsrWifiRouterCtrlMediaStatusReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->mediaStatus, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
 
     return primitive;
 }
@@ -204,19 +204,19 @@ CsrSize CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg)
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
-    bufferSize += 1; /* CsrUint8 primitive->getAddressesCount */
+    bufferSize += 1; /* u8 primitive->getAddressesCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
         {
-            bufferSize += 6; /* CsrUint8 primitive->getAddresses[i1].a[6] */
+            bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlMulticastAddressResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *)msg;
     *len = 0;
@@ -224,8 +224,8 @@ CsrUint8* CsrWifiRouterCtrlMulticastAddressResSer(CsrUint8 *ptr, CsrSize *len, v
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->getAddressesCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->getAddressesCount);
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
@@ -237,7 +237,7 @@ CsrUint8* CsrWifiRouterCtrlMulticastAddressResSer(CsrUint8 *ptr, CsrSize *len, v
 }
 
 
-void* CsrWifiRouterCtrlMulticastAddressResDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMulticastAddressRes));
     CsrSize offset;
@@ -247,8 +247,8 @@ void* CsrWifiRouterCtrlMulticastAddressResDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->getAddressesCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->getAddressesCount, buffer, &offset);
     primitive->getAddresses = NULL;
     if (primitive->getAddressesCount)
     {
@@ -283,13 +283,13 @@ CsrSize CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg)
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->uncontrolledPortAction */
     bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->controlledPortAction */
-    bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->macAddress.a[6] */
     bufferSize += 1; /* CsrBool primitive->setProtection */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlPortConfigureReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *)msg;
     *len = 0;
@@ -299,12 +299,12 @@ CsrUint8* CsrWifiRouterCtrlPortConfigureReqSer(CsrUint8 *ptr, CsrSize *len, void
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->uncontrolledPortAction);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->controlledPortAction);
     CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->setProtection);
+    CsrUint8Ser(ptr, len, (u8) primitive->setProtection);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlPortConfigureReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPortConfigureReq));
     CsrSize offset;
@@ -316,7 +316,7 @@ void* CsrWifiRouterCtrlPortConfigureReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->uncontrolledPortAction, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->controlledPortAction, buffer, &offset);
     CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->setProtection, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->setProtection, buffer, &offset);
 
     return primitive;
 }
@@ -335,7 +335,7 @@ CsrSize CsrWifiRouterCtrlQosControlReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlQosControlReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *)msg;
     *len = 0;
@@ -343,12 +343,12 @@ CsrUint8* CsrWifiRouterCtrlQosControlReqSer(CsrUint8 *ptr, CsrSize *len, void *m
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->control);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->queueConfig);
+    CsrUint8Ser(ptr, len, (u8) primitive->queueConfig);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlQosControlReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlQosControlReq));
     CsrSize offset;
@@ -358,7 +358,7 @@ void* CsrWifiRouterCtrlQosControlReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->control, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->queueConfig, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->queueConfig, buffer, &offset);
 
     return primitive;
 }
@@ -375,7 +375,7 @@ CsrSize CsrWifiRouterCtrlSuspendResSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlSuspendResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *)msg;
     *len = 0;
@@ -386,7 +386,7 @@ CsrUint8* CsrWifiRouterCtrlSuspendResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlSuspendResDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlSuspendRes));
     CsrSize offset;
@@ -409,12 +409,12 @@ CsrSize CsrWifiRouterCtrlTclasAddReqSizeof(void *msg)
     bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;                      /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2;                      /* CsrUint16 primitive->tclasLength */
-    bufferSize += primitive->tclasLength; /* CsrUint8 primitive->tclas */
+    bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlTclasAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *)msg;
     *len = 0;
@@ -430,7 +430,7 @@ CsrUint8* CsrWifiRouterCtrlTclasAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg
 }
 
 
-void* CsrWifiRouterCtrlTclasAddReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasAddReq));
     CsrSize offset;
@@ -442,7 +442,7 @@ void* CsrWifiRouterCtrlTclasAddReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
     if (primitive->tclasLength)
     {
-        primitive->tclas = (CsrUint8 *)CsrPmemAlloc(primitive->tclasLength);
+        primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
         CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
     }
     else
@@ -473,7 +473,7 @@ CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlResumeResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *)msg;
     *len = 0;
@@ -484,7 +484,7 @@ CsrUint8* CsrWifiRouterCtrlResumeResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlResumeResDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlResumeRes));
     CsrSize offset;
@@ -507,12 +507,12 @@ CsrSize CsrWifiRouterCtrlTclasDelReqSizeof(void *msg)
     bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;                      /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2;                      /* CsrUint16 primitive->tclasLength */
-    bufferSize += primitive->tclasLength; /* CsrUint8 primitive->tclas */
+    bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlTclasDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *)msg;
     *len = 0;
@@ -528,7 +528,7 @@ CsrUint8* CsrWifiRouterCtrlTclasDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg
 }
 
 
-void* CsrWifiRouterCtrlTclasDelReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasDelReq));
     CsrSize offset;
@@ -540,7 +540,7 @@ void* CsrWifiRouterCtrlTclasDelReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
     if (primitive->tclasLength)
     {
-        primitive->tclas = (CsrUint8 *)CsrPmemAlloc(primitive->tclasLength);
+        primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
         CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
     }
     else
@@ -573,20 +573,20 @@ CsrSize CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlTrafficClassificationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficType);
+    CsrUint8Ser(ptr, len, (u8) primitive->trafficType);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->period);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlTrafficClassificationReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficClassificationReq));
     CsrSize offset;
@@ -595,7 +595,7 @@ void* CsrWifiRouterCtrlTrafficClassificationReqDes(CsrUint8 *buffer, CsrSize len
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->trafficType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->trafficType, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->period, buffer, &offset);
 
     return primitive;
@@ -612,14 +612,14 @@ CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg)
     bufferSize += 2; /* CsrWifiRouterCtrlTrafficConfigType primitive->trafficConfigType */
     bufferSize += 2; /* CsrUint16 primitive->config.packetFilter */
     bufferSize += 4; /* CsrUint32 primitive->config.customFilter.etherType */
-    bufferSize += 1; /* CsrUint8 primitive->config.customFilter.ipType */
+    bufferSize += 1; /* u8 primitive->config.customFilter.ipType */
     bufferSize += 4; /* CsrUint32 primitive->config.customFilter.udpSourcePort */
     bufferSize += 4; /* CsrUint32 primitive->config.customFilter.udpDestPort */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlTrafficConfigReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *)msg;
     *len = 0;
@@ -629,14 +629,14 @@ CsrUint8* CsrWifiRouterCtrlTrafficConfigReqSer(CsrUint8 *ptr, CsrSize *len, void
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->trafficConfigType);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->config.packetFilter);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.etherType);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->config.customFilter.ipType);
+    CsrUint8Ser(ptr, len, (u8) primitive->config.customFilter.ipType);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.udpSourcePort);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.udpDestPort);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlTrafficConfigReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficConfigReq));
     CsrSize offset;
@@ -648,7 +648,7 @@ void* CsrWifiRouterCtrlTrafficConfigReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->trafficConfigType, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->config.packetFilter, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.etherType, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->config.customFilter.ipType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->config.customFilter.ipType, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.udpSourcePort, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.udpDestPort, buffer, &offset);
 
@@ -664,12 +664,12 @@ CsrSize CsrWifiRouterCtrlWifiOnReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2;                     /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 4;                     /* CsrUint32 primitive->dataLength */
-    bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+    bufferSize += primitive->dataLength; /* u8 primitive->data */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *)msg;
     *len = 0;
@@ -684,7 +684,7 @@ CsrUint8* CsrWifiRouterCtrlWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlWifiOnReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnReq));
     CsrSize offset;
@@ -695,7 +695,7 @@ void* CsrWifiRouterCtrlWifiOnReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
-        primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+        primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
         CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
     }
     else
@@ -728,7 +728,7 @@ CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg)
         CsrUint16 i1;
         for (i1 = 0; i1 < 2; i1++)
         {
-            bufferSize += 6;                                                                            /* CsrUint8 primitive->stationMacAddress[i1].a[6] */
+            bufferSize += 6;                                                                            /* u8 primitive->stationMacAddress[i1].a[6] */
         }
     }
     bufferSize += 4;                                                                                    /* CsrUint32 primitive->smeVersions.firmwarePatch */
@@ -739,7 +739,7 @@ CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlWifiOnResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *)msg;
     *len = 0;
@@ -757,12 +757,12 @@ CsrUint8* CsrWifiRouterCtrlWifiOnResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->smeVersions.firmwarePatch);
     CsrCharStringSer(ptr, len, primitive->smeVersions.smeBuild);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->smeVersions.smeHip);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scheduledInterrupt);
+    CsrUint8Ser(ptr, len, (u8) primitive->scheduledInterrupt);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlWifiOnResDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnRes));
     CsrSize offset;
@@ -782,7 +782,7 @@ void* CsrWifiRouterCtrlWifiOnResDes(CsrUint8 *buffer, CsrSize length)
     CsrUint32Des((CsrUint32 *) &primitive->smeVersions.firmwarePatch, buffer, &offset);
     CsrCharStringDes(&primitive->smeVersions.smeBuild, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->smeVersions.smeHip, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scheduledInterrupt, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scheduledInterrupt, buffer, &offset);
 
     return primitive;
 }
@@ -807,7 +807,7 @@ CsrSize CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlM4TransmitReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *)msg;
     *len = 0;
@@ -818,7 +818,7 @@ CsrUint8* CsrWifiRouterCtrlM4TransmitReqSer(CsrUint8 *ptr, CsrSize *len, void *m
 }
 
 
-void* CsrWifiRouterCtrlM4TransmitReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4TransmitReq));
     CsrSize offset;
@@ -840,29 +840,29 @@ CsrSize CsrWifiRouterCtrlModeSetReqSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
-    bufferSize += 6; /* CsrUint8 primitive->bssid.a[6] */
+    bufferSize += 6; /* u8 primitive->bssid.a[6] */
     bufferSize += 1; /* CsrBool primitive->protection */
     bufferSize += 1; /* CsrBool primitive->intraBssDistEnabled */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlModeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->mode);
+    CsrUint8Ser(ptr, len, (u8) primitive->mode);
     CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->protection);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->intraBssDistEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->protection);
+    CsrUint8Ser(ptr, len, (u8) primitive->intraBssDistEnabled);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlModeSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlModeSetReq));
     CsrSize offset;
@@ -871,10 +871,10 @@ void* CsrWifiRouterCtrlModeSetReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->mode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
     CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->protection, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->intraBssDistEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->protection, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->intraBssDistEnabled, buffer, &offset);
 
     return primitive;
 }
@@ -887,17 +887,17 @@ CsrSize CsrWifiRouterCtrlPeerAddReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 2; /* CsrUint16 primitive->associationId */
     bufferSize += 1; /* CsrBool primitive->staInfo.wmmOrQosEnabled */
     bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->staInfo.powersaveMode */
-    bufferSize += 1; /* CsrUint8 primitive->staInfo.maxSpLength */
+    bufferSize += 1; /* u8 primitive->staInfo.maxSpLength */
     bufferSize += 2; /* CsrUint16 primitive->staInfo.listenIntervalInTus */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlPeerAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *)msg;
     *len = 0;
@@ -906,15 +906,15 @@ CsrUint8* CsrWifiRouterCtrlPeerAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->associationId);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->staInfo.wmmOrQosEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->staInfo.wmmOrQosEnabled);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->staInfo.powersaveMode);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->staInfo.maxSpLength);
+    CsrUint8Ser(ptr, len, (u8) primitive->staInfo.maxSpLength);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->staInfo.listenIntervalInTus);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlPeerAddReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerAddReq));
     CsrSize offset;
@@ -925,9 +925,9 @@ void* CsrWifiRouterCtrlPeerAddReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
     CsrUint16Des((CsrUint16 *) &primitive->associationId, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->staInfo.wmmOrQosEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->staInfo.wmmOrQosEnabled, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->staInfo.powersaveMode, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->staInfo.maxSpLength, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->staInfo.maxSpLength, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->staInfo.listenIntervalInTus, buffer, &offset);
 
     return primitive;
@@ -946,7 +946,7 @@ CsrSize CsrWifiRouterCtrlPeerDelReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlPeerDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *)msg;
     *len = 0;
@@ -958,7 +958,7 @@ CsrUint8* CsrWifiRouterCtrlPeerDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPeerDelReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerDelReq));
     CsrSize offset;
@@ -986,7 +986,7 @@ CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlPeerUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *)msg;
     *len = 0;
@@ -999,7 +999,7 @@ CsrUint8* CsrWifiRouterCtrlPeerUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *m
 }
 
 
-void* CsrWifiRouterCtrlPeerUpdateReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerUpdateReq));
     CsrSize offset;
@@ -1022,7 +1022,7 @@ CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->macAddress.a[6] */
     bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
     bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
     bufferSize += 2; /* CsrUint16 primitive->bufferSize */
@@ -1032,7 +1032,7 @@ CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlBlockAckEnableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *)msg;
     *len = 0;
@@ -1040,8 +1040,8 @@ CsrUint8* CsrWifiRouterCtrlBlockAckEnableReqSer(CsrUint8 *ptr, CsrSize *len, voi
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficStreamID);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->role);
+    CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
+    CsrUint8Ser(ptr, len, (u8) primitive->role);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->bufferSize);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->timeout);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->ssn);
@@ -1049,7 +1049,7 @@ CsrUint8* CsrWifiRouterCtrlBlockAckEnableReqSer(CsrUint8 *ptr, CsrSize *len, voi
 }
 
 
-void* CsrWifiRouterCtrlBlockAckEnableReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckEnableReq));
     CsrSize offset;
@@ -1059,8 +1059,8 @@ void* CsrWifiRouterCtrlBlockAckEnableReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->trafficStreamID, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->role, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->bufferSize, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->timeout, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->ssn, buffer, &offset);
@@ -1076,14 +1076,14 @@ CsrSize CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
-    bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->macAddress.a[6] */
     bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
     bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlBlockAckDisableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *)msg;
     *len = 0;
@@ -1091,13 +1091,13 @@ CsrUint8* CsrWifiRouterCtrlBlockAckDisableReqSer(CsrUint8 *ptr, CsrSize *len, vo
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficStreamID);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->role);
+    CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
+    CsrUint8Ser(ptr, len, (u8) primitive->role);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlBlockAckDisableReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckDisableReq));
     CsrSize offset;
@@ -1107,8 +1107,8 @@ void* CsrWifiRouterCtrlBlockAckDisableReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->trafficStreamID, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->role, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->role, buffer, &offset);
 
     return primitive;
 }
@@ -1122,14 +1122,14 @@ CsrSize CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2;                       /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;                       /* CsrUint16 primitive->signalLength */
-    bufferSize += primitive->signalLength; /* CsrUint8 primitive->signal */
+    bufferSize += primitive->signalLength; /* u8 primitive->signal */
     bufferSize += 2;                       /* CsrUint16 primitive->dataLength */
-    bufferSize += primitive->dataLength;   /* CsrUint8 primitive->data */
+    bufferSize += primitive->dataLength;   /* u8 primitive->data */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlWapiRxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *)msg;
     *len = 0;
@@ -1149,7 +1149,7 @@ CsrUint8* CsrWifiRouterCtrlWapiRxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *ms
 }
 
 
-void* CsrWifiRouterCtrlWapiRxPktReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiRxPktReq));
     CsrSize offset;
@@ -1160,7 +1160,7 @@ void* CsrWifiRouterCtrlWapiRxPktReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->signalLength, buffer, &offset);
     if (primitive->signalLength)
     {
-        primitive->signal = (CsrUint8 *)CsrPmemAlloc(primitive->signalLength);
+        primitive->signal = (u8 *)CsrPmemAlloc(primitive->signalLength);
         CsrMemCpyDes(primitive->signal, buffer, &offset, ((CsrUint16) (primitive->signalLength)));
     }
     else
@@ -1170,7 +1170,7 @@ void* CsrWifiRouterCtrlWapiRxPktReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
-        primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+        primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
         CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
     }
     else
@@ -1199,12 +1199,12 @@ CsrSize CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2;                     /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;                     /* CsrUint16 primitive->dataLength */
-    bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+    bufferSize += primitive->dataLength; /* u8 primitive->data */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *)msg;
     *len = 0;
@@ -1219,7 +1219,7 @@ CsrUint8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(CsrUint8 *ptr, CsrSize *len, v
 }
 
 
-void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxPktReq));
     CsrSize offset;
@@ -1230,7 +1230,7 @@ void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
-        primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+        primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
         CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
     }
     else
@@ -1257,16 +1257,16 @@ CsrSize CsrWifiRouterCtrlHipIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
     bufferSize += 2;                            /* CsrUint16 primitive->mlmeCommandLength */
-    bufferSize += primitive->mlmeCommandLength; /* CsrUint8 primitive->mlmeCommand */
+    bufferSize += primitive->mlmeCommandLength; /* u8 primitive->mlmeCommand */
     bufferSize += 2;                            /* CsrUint16 primitive->dataRef1Length */
-    bufferSize += primitive->dataRef1Length;    /* CsrUint8 primitive->dataRef1 */
+    bufferSize += primitive->dataRef1Length;    /* u8 primitive->dataRef1 */
     bufferSize += 2;                            /* CsrUint16 primitive->dataRef2Length */
-    bufferSize += primitive->dataRef2Length;    /* CsrUint8 primitive->dataRef2 */
+    bufferSize += primitive->dataRef2Length;    /* u8 primitive->dataRef2 */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlHipIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *)msg;
     *len = 0;
@@ -1290,7 +1290,7 @@ CsrUint8* CsrWifiRouterCtrlHipIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlHipIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlHipInd));
     CsrSize offset;
@@ -1300,7 +1300,7 @@ void* CsrWifiRouterCtrlHipIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->mlmeCommandLength, buffer, &offset);
     if (primitive->mlmeCommandLength)
     {
-        primitive->mlmeCommand = (CsrUint8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
+        primitive->mlmeCommand = (u8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
         CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((CsrUint16) (primitive->mlmeCommandLength)));
     }
     else
@@ -1310,7 +1310,7 @@ void* CsrWifiRouterCtrlHipIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->dataRef1Length, buffer, &offset);
     if (primitive->dataRef1Length)
     {
-        primitive->dataRef1 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef1Length);
+        primitive->dataRef1 = (u8 *)CsrPmemAlloc(primitive->dataRef1Length);
         CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((CsrUint16) (primitive->dataRef1Length)));
     }
     else
@@ -1320,7 +1320,7 @@ void* CsrWifiRouterCtrlHipIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->dataRef2Length, buffer, &offset);
     if (primitive->dataRef2Length)
     {
-        primitive->dataRef2 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef2Length);
+        primitive->dataRef2 = (u8 *)CsrPmemAlloc(primitive->dataRef2Length);
         CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((CsrUint16) (primitive->dataRef2Length)));
     }
     else
@@ -1351,27 +1351,27 @@ CsrSize CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg)
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
-    bufferSize += 1; /* CsrUint8 primitive->setAddressesCount */
+    bufferSize += 1; /* u8 primitive->setAddressesCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
         {
-            bufferSize += 6; /* CsrUint8 primitive->setAddresses[i1].a[6] */
+            bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlMulticastAddressIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->setAddressesCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->setAddressesCount);
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
@@ -1383,7 +1383,7 @@ CsrUint8* CsrWifiRouterCtrlMulticastAddressIndSer(CsrUint8 *ptr, CsrSize *len, v
 }
 
 
-void* CsrWifiRouterCtrlMulticastAddressIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMulticastAddressInd));
     CsrSize offset;
@@ -1392,8 +1392,8 @@ void* CsrWifiRouterCtrlMulticastAddressIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->setAddressesCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->setAddressesCount, buffer, &offset);
     primitive->setAddresses = NULL;
     if (primitive->setAddressesCount)
     {
@@ -1427,12 +1427,12 @@ CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg)
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->macAddress.a[6] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlPortConfigureCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *)msg;
     *len = 0;
@@ -1445,7 +1445,7 @@ CsrUint8* CsrWifiRouterCtrlPortConfigureCfmSer(CsrUint8 *ptr, CsrSize *len, void
 }
 
 
-void* CsrWifiRouterCtrlPortConfigureCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPortConfigureCfm));
     CsrSize offset;
@@ -1473,19 +1473,19 @@ CsrSize CsrWifiRouterCtrlSuspendIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlSuspendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->hardSuspend);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->d3Suspend);
+    CsrUint8Ser(ptr, len, (u8) primitive->hardSuspend);
+    CsrUint8Ser(ptr, len, (u8) primitive->d3Suspend);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlSuspendIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlSuspendInd));
     CsrSize offset;
@@ -1493,8 +1493,8 @@ void* CsrWifiRouterCtrlSuspendIndDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->hardSuspend, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->d3Suspend, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->hardSuspend, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->d3Suspend, buffer, &offset);
 
     return primitive;
 }
@@ -1512,7 +1512,7 @@ CsrSize CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlTclasAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *)msg;
     *len = 0;
@@ -1524,7 +1524,7 @@ CsrUint8* CsrWifiRouterCtrlTclasAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg
 }
 
 
-void* CsrWifiRouterCtrlTclasAddCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasAddCfm));
     CsrSize offset;
@@ -1550,7 +1550,7 @@ CsrSize CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *)msg;
     *len = 0;
@@ -1561,7 +1561,7 @@ CsrUint8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(CsrUint8 *ptr, CsrSize *len
 }
 
 
-void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioDeinitialiseCfm));
     CsrSize offset;
@@ -1594,7 +1594,7 @@ CsrSize CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *)msg;
     *len = 0;
@@ -1613,7 +1613,7 @@ CsrUint8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(CsrUint8 *ptr, CsrSize *len,
 }
 
 
-void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioInitialiseCfm));
     CsrSize offset;
@@ -1655,7 +1655,7 @@ CsrSize CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlTclasDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *)msg;
     *len = 0;
@@ -1667,7 +1667,7 @@ CsrUint8* CsrWifiRouterCtrlTclasDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg
 }
 
 
-void* CsrWifiRouterCtrlTclasDelCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasDelCfm));
     CsrSize offset;
@@ -1691,12 +1691,12 @@ CsrSize CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrWifiRouterCtrlTrafficPacketType primitive->packetType */
     bufferSize += 2; /* CsrWifiRouterCtrlProtocolDirection primitive->direction */
-    bufferSize += 6; /* CsrUint8 primitive->srcAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->srcAddress.a[6] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlTrafficProtocolIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *)msg;
     *len = 0;
@@ -1710,7 +1710,7 @@ CsrUint8* CsrWifiRouterCtrlTrafficProtocolIndSer(CsrUint8 *ptr, CsrSize *len, vo
 }
 
 
-void* CsrWifiRouterCtrlTrafficProtocolIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficProtocolInd));
     CsrSize offset;
@@ -1739,12 +1739,12 @@ CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg)
     bufferSize += 4;  /* CsrUint32 primitive->stats.txFramesNum */
     bufferSize += 4;  /* CsrUint32 primitive->stats.rxBytesCount */
     bufferSize += 4;  /* CsrUint32 primitive->stats.txBytesCount */
-    bufferSize += 11; /* CsrUint8 primitive->stats.intervals[11] */
+    bufferSize += 11; /* u8 primitive->stats.intervals[11] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlTrafficSampleIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *)msg;
     *len = 0;
@@ -1761,7 +1761,7 @@ CsrUint8* CsrWifiRouterCtrlTrafficSampleIndSer(CsrUint8 *ptr, CsrSize *len, void
 }
 
 
-void* CsrWifiRouterCtrlTrafficSampleIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficSampleInd));
     CsrSize offset;
@@ -1799,7 +1799,7 @@ CsrSize CsrWifiRouterCtrlWifiOnIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *)msg;
     *len = 0;
@@ -1816,7 +1816,7 @@ CsrUint8* CsrWifiRouterCtrlWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlWifiOnIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnInd));
     CsrSize offset;
@@ -1855,7 +1855,7 @@ CsrSize CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlWifiOnCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *)msg;
     *len = 0;
@@ -1866,7 +1866,7 @@ CsrUint8* CsrWifiRouterCtrlWifiOnCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlWifiOnCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnCfm));
     CsrSize offset;
@@ -1887,12 +1887,12 @@ 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 += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlM4ReadyToSendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *)msg;
     *len = 0;
@@ -1904,7 +1904,7 @@ CsrUint8* CsrWifiRouterCtrlM4ReadyToSendIndSer(CsrUint8 *ptr, CsrSize *len, void
 }
 
 
-void* CsrWifiRouterCtrlM4ReadyToSendIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4ReadyToSendInd));
     CsrSize offset;
@@ -1926,13 +1926,13 @@ 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 += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlM4TransmittedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *)msg;
     *len = 0;
@@ -1945,7 +1945,7 @@ CsrUint8* CsrWifiRouterCtrlM4TransmittedIndSer(CsrUint8 *ptr, CsrSize *len, void
 }
 
 
-void* CsrWifiRouterCtrlM4TransmittedIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4TransmittedInd));
     CsrSize offset;
@@ -1968,13 +1968,13 @@ 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 += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 1; /* CsrBool primitive->unicastPdu */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *)msg;
     *len = 0;
@@ -1982,12 +1982,12 @@ CsrUint8* CsrWifiRouterCtrlMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *m
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->unicastPdu);
+    CsrUint8Ser(ptr, len, (u8) primitive->unicastPdu);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlMicFailureIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMicFailureInd));
     CsrSize offset;
@@ -1997,7 +1997,7 @@ void* CsrWifiRouterCtrlMicFailureIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->unicastPdu, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->unicastPdu, buffer, &offset);
 
     return primitive;
 }
@@ -2010,13 +2010,13 @@ 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 += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 1; /* CsrWifiRouterCtrlPeerStatus primitive->peerStatus */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlConnectedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *)msg;
     *len = 0;
@@ -2024,12 +2024,12 @@ CsrUint8* CsrWifiRouterCtrlConnectedIndSer(CsrUint8 *ptr, CsrSize *len, void *ms
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->peerStatus);
+    CsrUint8Ser(ptr, len, (u8) primitive->peerStatus);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlConnectedIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlConnectedInd));
     CsrSize offset;
@@ -2039,7 +2039,7 @@ void* CsrWifiRouterCtrlConnectedIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->peerStatus, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->peerStatus, buffer, &offset);
 
     return primitive;
 }
@@ -2052,14 +2052,14 @@ 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 += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlPeerAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *)msg;
     *len = 0;
@@ -2073,7 +2073,7 @@ CsrUint8* CsrWifiRouterCtrlPeerAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPeerAddCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerAddCfm));
     CsrSize offset;
@@ -2102,7 +2102,7 @@ CsrSize CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlPeerDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *)msg;
     *len = 0;
@@ -2114,7 +2114,7 @@ CsrUint8* CsrWifiRouterCtrlPeerDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterCtrlPeerDelCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerDelCfm));
     CsrSize offset;
@@ -2136,12 +2136,12 @@ 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 += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlUnexpectedFrameIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *)msg;
     *len = 0;
@@ -2153,7 +2153,7 @@ CsrUint8* CsrWifiRouterCtrlUnexpectedFrameIndSer(CsrUint8 *ptr, CsrSize *len, vo
 }
 
 
-void* CsrWifiRouterCtrlUnexpectedFrameIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlUnexpectedFrameInd));
     CsrSize offset;
@@ -2180,7 +2180,7 @@ CsrSize CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlPeerUpdateCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *)msg;
     *len = 0;
@@ -2192,7 +2192,7 @@ CsrUint8* CsrWifiRouterCtrlPeerUpdateCfmSer(CsrUint8 *ptr, CsrSize *len, void *m
 }
 
 
-void* CsrWifiRouterCtrlPeerUpdateCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerUpdateCfm));
     CsrSize offset;
@@ -2219,7 +2219,7 @@ CsrSize CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlCapabilitiesCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *)msg;
     *len = 0;
@@ -2231,7 +2231,7 @@ CsrUint8* CsrWifiRouterCtrlCapabilitiesCfmSer(CsrUint8 *ptr, CsrSize *len, void
 }
 
 
-void* CsrWifiRouterCtrlCapabilitiesCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlCapabilitiesCfm));
     CsrSize offset;
@@ -2258,7 +2258,7 @@ CsrSize CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlBlockAckEnableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *)msg;
     *len = 0;
@@ -2270,7 +2270,7 @@ CsrUint8* CsrWifiRouterCtrlBlockAckEnableCfmSer(CsrUint8 *ptr, CsrSize *len, voi
 }
 
 
-void* CsrWifiRouterCtrlBlockAckEnableCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckEnableCfm));
     CsrSize offset;
@@ -2297,7 +2297,7 @@ CsrSize CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlBlockAckDisableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *)msg;
     *len = 0;
@@ -2309,7 +2309,7 @@ CsrUint8* CsrWifiRouterCtrlBlockAckDisableCfmSer(CsrUint8 *ptr, CsrSize *len, vo
 }
 
 
-void* CsrWifiRouterCtrlBlockAckDisableCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckDisableCfm));
     CsrSize offset;
@@ -2332,27 +2332,27 @@ CsrSize CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg)
     bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
-    bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     bufferSize += 2; /* CsrResult primitive->status */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlBlockAckErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficStreamID);
+    CsrUint8Ser(ptr, len, (u8) primitive->trafficStreamID);
     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlBlockAckErrorIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckErrorInd));
     CsrSize offset;
@@ -2361,7 +2361,7 @@ void* CsrWifiRouterCtrlBlockAckErrorIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->trafficStreamID, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->trafficStreamID, buffer, &offset);
     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
 
@@ -2376,12 +2376,12 @@ 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 += 6; /* CsrUint8 primitive->staAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->staAddress.a[6] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlStaInactiveIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *)msg;
     *len = 0;
@@ -2393,7 +2393,7 @@ CsrUint8* CsrWifiRouterCtrlStaInactiveIndSer(CsrUint8 *ptr, CsrSize *len, void *
 }
 
 
-void* CsrWifiRouterCtrlStaInactiveIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlStaInactiveInd));
     CsrSize offset;
@@ -2417,14 +2417,14 @@ CsrSize CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg)
     bufferSize += 2;                       /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2;                       /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;                       /* CsrUint16 primitive->signalLength */
-    bufferSize += primitive->signalLength; /* CsrUint8 primitive->signal */
+    bufferSize += primitive->signalLength; /* u8 primitive->signal */
     bufferSize += 2;                       /* CsrUint16 primitive->dataLength */
-    bufferSize += primitive->dataLength;   /* CsrUint8 primitive->data */
+    bufferSize += primitive->dataLength;   /* u8 primitive->data */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *)msg;
     *len = 0;
@@ -2445,7 +2445,7 @@ CsrUint8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(CsrUint8 *ptr, CsrSize *len, voi
 }
 
 
-void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiRxMicCheckInd));
     CsrSize offset;
@@ -2457,7 +2457,7 @@ void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->signalLength, buffer, &offset);
     if (primitive->signalLength)
     {
-        primitive->signal = (CsrUint8 *)CsrPmemAlloc(primitive->signalLength);
+        primitive->signal = (u8 *)CsrPmemAlloc(primitive->signalLength);
         CsrMemCpyDes(primitive->signal, buffer, &offset, ((CsrUint16) (primitive->signalLength)));
     }
     else
@@ -2467,7 +2467,7 @@ void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
-        primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+        primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
         CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
     }
     else
@@ -2501,20 +2501,20 @@ CsrSize CsrWifiRouterCtrlModeSetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterCtrlModeSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->mode);
+    CsrUint8Ser(ptr, len, (u8) primitive->mode);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
     return(ptr);
 }
 
 
-void* CsrWifiRouterCtrlModeSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlModeSetCfm));
     CsrSize offset;
@@ -2523,7 +2523,7 @@ void* CsrWifiRouterCtrlModeSetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->mode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
 
     return primitive;
@@ -2539,12 +2539,12 @@ CsrSize CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg)
     bufferSize += 2;                     /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
     bufferSize += 2;                     /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;                     /* CsrUint16 primitive->dataLength */
-    bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+    bufferSize += primitive->dataLength; /* u8 primitive->data */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *)msg;
     *len = 0;
@@ -2560,7 +2560,7 @@ CsrUint8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(CsrUint8 *ptr, CsrSize *le
 }
 
 
-void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxEncryptInd));
     CsrSize offset;
@@ -2572,7 +2572,7 @@ void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(CsrUint8 *buffer, CsrSize leng
     CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
-        primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+        primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
         CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
     }
     else
diff --git a/drivers/staging/csr/csr_wifi_router_ctrl_serialize.h b/drivers/staging/csr/csr_wifi_router_ctrl_serialize.h
index 3b7834dad52..5a17a455c81 100644
--- a/drivers/staging/csr/csr_wifi_router_ctrl_serialize.h
+++ b/drivers/staging/csr/csr_wifi_router_ctrl_serialize.h
@@ -25,48 +25,48 @@ extern "C" {
 
 extern void CsrWifiRouterCtrlPfree(void *ptr);
 
-extern CsrUint8* CsrWifiRouterCtrlConfigurePowerModeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlConfigurePowerModeReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg);
 #define CsrWifiRouterCtrlConfigurePowerModeReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlHipReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlHipReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlHipReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlHipReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterCtrlMediaStatusReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMediaStatusReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg);
 #define CsrWifiRouterCtrlMediaStatusReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlMulticastAddressResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMulticastAddressResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg);
 extern void CsrWifiRouterCtrlMulticastAddressResSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterCtrlPortConfigureReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPortConfigureReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg);
 #define CsrWifiRouterCtrlPortConfigureReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlQosControlReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlQosControlReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlQosControlReqSizeof(void *msg);
 #define CsrWifiRouterCtrlQosControlReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlSuspendResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlSuspendResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlSuspendResSizeof(void *msg);
 #define CsrWifiRouterCtrlSuspendResSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlTclasAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasAddReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlTclasAddReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlTclasAddReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterCtrlResumeResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlResumeResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg);
 #define CsrWifiRouterCtrlResumeResSerFree CsrWifiRouterCtrlPfree
 
@@ -80,18 +80,18 @@ extern CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg);
 #define CsrWifiRouterCtrlRawSdioInitialiseReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiRouterCtrlRawSdioInitialiseReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlTclasDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasDelReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlTclasDelReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlTclasDelReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterCtrlTrafficClassificationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficClassificationReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg);
 #define CsrWifiRouterCtrlTrafficClassificationReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlTrafficConfigReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficConfigReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg);
 #define CsrWifiRouterCtrlTrafficConfigReqSerFree CsrWifiRouterCtrlPfree
 
@@ -105,38 +105,38 @@ extern CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg);
 #define CsrWifiRouterCtrlWifiOffResSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiRouterCtrlWifiOffResSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlWifiOnReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlWifiOnReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterCtrlWifiOnResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg);
 extern void CsrWifiRouterCtrlWifiOnResSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterCtrlM4TransmitReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlM4TransmitReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg);
 #define CsrWifiRouterCtrlM4TransmitReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlModeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlModeSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlModeSetReqSizeof(void *msg);
 #define CsrWifiRouterCtrlModeSetReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlPeerAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerAddReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlPeerAddReqSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerAddReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlPeerDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerDelReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlPeerDelReqSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerDelReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlPeerUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerUpdateReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerUpdateReqSerFree CsrWifiRouterCtrlPfree
 
@@ -145,18 +145,18 @@ extern CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg);
 #define CsrWifiRouterCtrlCapabilitiesReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiRouterCtrlCapabilitiesReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlBlockAckEnableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckEnableReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg);
 #define CsrWifiRouterCtrlBlockAckEnableReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlBlockAckDisableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckDisableReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg);
 #define CsrWifiRouterCtrlBlockAckDisableReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlWapiRxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiRxPktReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *msg);
 
@@ -170,8 +170,8 @@ extern void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *msg);
 #define CsrWifiRouterCtrlWapiUnicastFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
 #define CsrWifiRouterCtrlWapiUnicastFilterReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg);
 extern void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *msg);
 
@@ -180,18 +180,18 @@ extern void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *msg);
 #define CsrWifiRouterCtrlWapiFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
 #define CsrWifiRouterCtrlWapiFilterReqSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlHipIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlHipIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlHipIndSizeof(void *msg);
 extern void CsrWifiRouterCtrlHipIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterCtrlMulticastAddressIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMulticastAddressIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg);
 extern void CsrWifiRouterCtrlMulticastAddressIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterCtrlPortConfigureCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPortConfigureCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlPortConfigureCfmSerFree CsrWifiRouterCtrlPfree
 
@@ -200,38 +200,38 @@ extern CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlResumeIndSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
 #define CsrWifiRouterCtrlResumeIndSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlSuspendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlSuspendIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlSuspendIndSizeof(void *msg);
 #define CsrWifiRouterCtrlSuspendIndSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlTclasAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasAddCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlTclasAddCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlRawSdioDeinitialiseCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlRawSdioInitialiseCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlTclasDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTclasDelCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlTclasDelCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlTrafficProtocolIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficProtocolIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg);
 #define CsrWifiRouterCtrlTrafficProtocolIndSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlTrafficSampleIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlTrafficSampleIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg);
 #define CsrWifiRouterCtrlTrafficSampleIndSerFree CsrWifiRouterCtrlPfree
 
@@ -245,93 +245,93 @@ extern CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg);
 #define CsrWifiRouterCtrlWifiOffCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiRouterCtrlWifiOffCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlWifiOnIndSizeof(void *msg);
 extern void CsrWifiRouterCtrlWifiOnIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterCtrlWifiOnCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWifiOnCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlWifiOnCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlM4ReadyToSendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlM4ReadyToSendIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg);
 #define CsrWifiRouterCtrlM4ReadyToSendIndSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlM4TransmittedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlM4TransmittedIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg);
 #define CsrWifiRouterCtrlM4TransmittedIndSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlMicFailureIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlMicFailureIndSizeof(void *msg);
 #define CsrWifiRouterCtrlMicFailureIndSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlConnectedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlConnectedIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlConnectedIndSizeof(void *msg);
 #define CsrWifiRouterCtrlConnectedIndSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlPeerAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerAddCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerAddCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlPeerDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerDelCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerDelCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlUnexpectedFrameIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlUnexpectedFrameIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg);
 #define CsrWifiRouterCtrlUnexpectedFrameIndSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlPeerUpdateCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlPeerUpdateCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlPeerUpdateCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlCapabilitiesCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlCapabilitiesCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlCapabilitiesCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlBlockAckEnableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckEnableCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlBlockAckEnableCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlBlockAckDisableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckDisableCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlBlockAckDisableCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlBlockAckErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlBlockAckErrorIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg);
 #define CsrWifiRouterCtrlBlockAckErrorIndSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlStaInactiveIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlStaInactiveIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg);
 #define CsrWifiRouterCtrlStaInactiveIndSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg);
 extern void CsrWifiRouterCtrlWapiRxMicCheckIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterCtrlModeSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlModeSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlModeSetCfmSizeof(void *msg);
 #define CsrWifiRouterCtrlModeSetCfmSerFree CsrWifiRouterCtrlPfree
 
-extern CsrUint8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg);
 extern void CsrWifiRouterCtrlWapiUnicastTxEncryptIndSerFree(void *msg);
 
diff --git a/drivers/staging/csr/csr_wifi_router_prim.h b/drivers/staging/csr/csr_wifi_router_prim.h
index 67b71a4739a..182cbfc3dd3 100644
--- a/drivers/staging/csr/csr_wifi_router_prim.h
+++ b/drivers/staging/csr/csr_wifi_router_prim.h
@@ -44,7 +44,7 @@ typedef void (*CsrWifiRouterFrameFreeFunction)(void *frame);
     CSR_WIFI_ROUTER_APP_TYPE_OTHER -
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterAppType;
+typedef u8 CsrWifiRouterAppType;
 #define CSR_WIFI_ROUTER_APP_TYPE_SME     ((CsrWifiRouterAppType) 0x0)
 #define CSR_WIFI_ROUTER_APP_TYPE_PAL     ((CsrWifiRouterAppType) 0x1)
 #define CSR_WIFI_ROUTER_APP_TYPE_NME     ((CsrWifiRouterAppType) 0x2)
@@ -65,7 +65,7 @@ typedef CsrUint8 CsrWifiRouterAppType;
                    - LLC/SNAP encapsulation
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiRouterEncapsulation;
+typedef u8 CsrWifiRouterEncapsulation;
 #define CSR_WIFI_ROUTER_ENCAPSULATION_ETHERNET   ((CsrWifiRouterEncapsulation) 0x00)
 #define CSR_WIFI_ROUTER_ENCAPSULATION_LLC_SNAP   ((CsrWifiRouterEncapsulation) 0x01)
 
@@ -204,7 +204,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       interfaceTag;
-    CsrUint8        subscriptionHandle;
+    u8        subscriptionHandle;
 } CsrWifiRouterMaPacketUnsubscribeReq;
 
 /*******************************************************************************
@@ -243,9 +243,9 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrUint16                      interfaceTag;
-    CsrUint8                       subscriptionHandle;
+    u8                       subscriptionHandle;
     CsrUint16                      frameLength;
-    CsrUint8                      *frame;
+    u8                      *frame;
     CsrWifiRouterFrameFreeFunction freeFunction;
     CsrWifiRouterPriority          priority;
     CsrUint32                      hostTag;
@@ -272,7 +272,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       interfaceTag;
-    CsrUint8        subscriptionHandle;
+    u8        subscriptionHandle;
     CsrResult       result;
 } CsrWifiRouterMaPacketRes;
 
@@ -332,7 +332,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       interfaceTag;
-    CsrUint8        subscriptionHandle;
+    u8        subscriptionHandle;
     CsrResult       status;
     CsrUint16       allocOffset;
 } CsrWifiRouterMaPacketSubscribeCfm;
@@ -411,10 +411,10 @@ typedef struct
 {
     CsrWifiFsmEvent                common;
     CsrUint16                      interfaceTag;
-    CsrUint8                       subscriptionHandle;
+    u8                       subscriptionHandle;
     CsrResult                      result;
     CsrUint16                      frameLength;
-    CsrUint8                      *frame;
+    u8                      *frame;
     CsrWifiRouterFrameFreeFunction freeFunction;
     CsrInt16                       rssi;
     CsrInt16                       snr;
diff --git a/drivers/staging/csr/csr_wifi_router_serialize.c b/drivers/staging/csr/csr_wifi_router_serialize.c
index e1adf8f0364..e744db885b8 100644
--- a/drivers/staging/csr/csr_wifi_router_serialize.c
+++ b/drivers/staging/csr/csr_wifi_router_serialize.c
@@ -37,20 +37,20 @@ CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterMaPacketSubscribeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->encapsulation);
+    CsrUint8Ser(ptr, len, (u8) primitive->encapsulation);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->protocol);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->oui);
     return(ptr);
 }
 
 
-void* CsrWifiRouterMaPacketSubscribeReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeReq));
     CsrSize offset;
@@ -58,7 +58,7 @@ void* CsrWifiRouterMaPacketSubscribeReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->encapsulation, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->encapsulation, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->protocol, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->oui, buffer, &offset);
 
@@ -73,9 +73,9 @@ CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 20) */
     bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 1;                      /* CsrUint8 primitive->subscriptionHandle */
+    bufferSize += 1;                      /* u8 primitive->subscriptionHandle */
     bufferSize += 2;                      /* CsrUint16 primitive->frameLength */
-    bufferSize += primitive->frameLength; /* CsrUint8 primitive->frame */
+    bufferSize += primitive->frameLength; /* u8 primitive->frame */
     bufferSize += 4;                      /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
     bufferSize += 2;                      /* CsrWifiRouterPriority primitive->priority */
     bufferSize += 4;                      /* CsrUint32 primitive->hostTag */
@@ -84,13 +84,13 @@ CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterMaPacketReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+    CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->frameLength);
     if (primitive->frameLength)
     {
@@ -99,12 +99,12 @@ CsrUint8* CsrWifiRouterMaPacketReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
     CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->priority);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->cfmRequested);
+    CsrUint8Ser(ptr, len, (u8) primitive->cfmRequested);
     return(ptr);
 }
 
 
-void* CsrWifiRouterMaPacketReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketReq));
     CsrSize offset;
@@ -112,11 +112,11 @@ void* CsrWifiRouterMaPacketReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->frameLength, buffer, &offset);
     if (primitive->frameLength)
     {
-        primitive->frame = (CsrUint8 *)CsrPmemAlloc(primitive->frameLength);
+        primitive->frame = (u8 *)CsrPmemAlloc(primitive->frameLength);
         CsrMemCpyDes(primitive->frame, buffer, &offset, ((CsrUint16) (primitive->frameLength)));
     }
     else
@@ -127,7 +127,7 @@ void* CsrWifiRouterMaPacketReqDes(CsrUint8 *buffer, CsrSize length)
     offset += 4;
     CsrUint16Des((CsrUint16 *) &primitive->priority, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->cfmRequested, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->cfmRequested, buffer, &offset);
 
     return primitive;
 }
@@ -147,25 +147,25 @@ CsrSize CsrWifiRouterMaPacketResSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 1; /* CsrUint8 primitive->subscriptionHandle */
+    bufferSize += 1; /* u8 primitive->subscriptionHandle */
     bufferSize += 2; /* CsrResult primitive->result */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterMaPacketResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+    CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
     return(ptr);
 }
 
 
-void* CsrWifiRouterMaPacketResDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketRes));
     CsrSize offset;
@@ -173,7 +173,7 @@ void* CsrWifiRouterMaPacketResDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
 
     return primitive;
@@ -188,12 +188,12 @@ CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 4; /* CsrUint32 primitive->hostTag */
     bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
-    bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterMaPacketCancelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *)msg;
     *len = 0;
@@ -206,7 +206,7 @@ CsrUint8* CsrWifiRouterMaPacketCancelReqSer(CsrUint8 *ptr, CsrSize *len, void *m
 }
 
 
-void* CsrWifiRouterMaPacketCancelReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCancelReq));
     CsrSize offset;
@@ -228,27 +228,27 @@ CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 1; /* CsrUint8 primitive->subscriptionHandle */
+    bufferSize += 1; /* u8 primitive->subscriptionHandle */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 2; /* CsrUint16 primitive->allocOffset */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiRouterMaPacketSubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+    CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->allocOffset);
     return(ptr);
 }
 
 
-void* CsrWifiRouterMaPacketSubscribeCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeCfm));
     CsrSize offset;
@@ -256,7 +256,7 @@ void* CsrWifiRouterMaPacketSubscribeCfmDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->allocOffset, buffer, &offset);
 
@@ -275,7 +275,7 @@ CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterMaPacketUnsubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *)msg;
     *len = 0;
@@ -286,7 +286,7 @@ CsrUint8* CsrWifiRouterMaPacketUnsubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, vo
 }
 
 
-void* CsrWifiRouterMaPacketUnsubscribeCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketUnsubscribeCfm));
     CsrSize offset;
@@ -313,7 +313,7 @@ CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterMaPacketCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *)msg;
     *len = 0;
@@ -326,7 +326,7 @@ CsrUint8* CsrWifiRouterMaPacketCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterMaPacketCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCfm));
     CsrSize offset;
@@ -349,10 +349,10 @@ CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
     bufferSize += 2;                      /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 1;                      /* CsrUint8 primitive->subscriptionHandle */
+    bufferSize += 1;                      /* u8 primitive->subscriptionHandle */
     bufferSize += 2;                      /* CsrResult primitive->result */
     bufferSize += 2;                      /* CsrUint16 primitive->frameLength */
-    bufferSize += primitive->frameLength; /* CsrUint8 primitive->frame */
+    bufferSize += primitive->frameLength; /* u8 primitive->frame */
     bufferSize += 4;                      /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
     bufferSize += 2;                      /* CsrInt16 primitive->rssi */
     bufferSize += 2;                      /* CsrInt16 primitive->snr */
@@ -361,13 +361,13 @@ CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiRouterMaPacketIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+    CsrUint8Ser(ptr, len, (u8) primitive->subscriptionHandle);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->frameLength);
     if (primitive->frameLength)
@@ -382,7 +382,7 @@ CsrUint8* CsrWifiRouterMaPacketIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiRouterMaPacketIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiRouterMaPacketIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketInd));
     CsrSize offset;
@@ -390,12 +390,12 @@ void* CsrWifiRouterMaPacketIndDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->subscriptionHandle, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->frameLength, buffer, &offset);
     if (primitive->frameLength)
     {
-        primitive->frame = (CsrUint8 *)CsrPmemAlloc(primitive->frameLength);
+        primitive->frame = (u8 *)CsrPmemAlloc(primitive->frameLength);
         CsrMemCpyDes(primitive->frame, buffer, &offset, ((CsrUint16) (primitive->frameLength)));
     }
     else
diff --git a/drivers/staging/csr/csr_wifi_router_serialize.h b/drivers/staging/csr/csr_wifi_router_serialize.h
index 183a5a48bb4..6a6c1b2d214 100644
--- a/drivers/staging/csr/csr_wifi_router_serialize.h
+++ b/drivers/staging/csr/csr_wifi_router_serialize.h
@@ -25,8 +25,8 @@ extern "C" {
 
 extern void CsrWifiRouterPfree(void *ptr);
 
-extern CsrUint8* CsrWifiRouterMaPacketSubscribeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketSubscribeReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg);
 #define CsrWifiRouterMaPacketSubscribeReqSerFree CsrWifiRouterPfree
 
@@ -35,38 +35,38 @@ extern CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg);
 #define CsrWifiRouterMaPacketUnsubscribeReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
 #define CsrWifiRouterMaPacketUnsubscribeReqSerFree CsrWifiRouterPfree
 
-extern CsrUint8* CsrWifiRouterMaPacketReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg);
 extern void CsrWifiRouterMaPacketReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiRouterMaPacketResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketResDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterMaPacketResSizeof(void *msg);
 #define CsrWifiRouterMaPacketResSerFree CsrWifiRouterPfree
 
-extern CsrUint8* CsrWifiRouterMaPacketCancelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketCancelReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg);
 #define CsrWifiRouterMaPacketCancelReqSerFree CsrWifiRouterPfree
 
-extern CsrUint8* CsrWifiRouterMaPacketSubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketSubscribeCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg);
 #define CsrWifiRouterMaPacketSubscribeCfmSerFree CsrWifiRouterPfree
 
-extern CsrUint8* CsrWifiRouterMaPacketUnsubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketUnsubscribeCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg);
 #define CsrWifiRouterMaPacketUnsubscribeCfmSerFree CsrWifiRouterPfree
 
-extern CsrUint8* CsrWifiRouterMaPacketCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg);
 #define CsrWifiRouterMaPacketCfmSerFree CsrWifiRouterPfree
 
-extern CsrUint8* CsrWifiRouterMaPacketIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiRouterMaPacketIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg);
 extern void CsrWifiRouterMaPacketIndSerFree(void *msg);
 
diff --git a/drivers/staging/csr/csr_wifi_router_transport.c b/drivers/staging/csr/csr_wifi_router_transport.c
index ec7e01dda40..45bee240deb 100644
--- a/drivers/staging/csr/csr_wifi_router_transport.c
+++ b/drivers/staging/csr/csr_wifi_router_transport.c
@@ -61,7 +61,7 @@ void CsrWifiRouterTransportDeinit(unifi_priv_t *priv)
     }
 }
 
-void CsrWifiRouterTransportRecv(unifi_priv_t *priv, CsrUint8* buffer, CsrSize bufferLength)
+void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLength)
 {
     CsrMsgConvMsgEntry* msgEntry;
     CsrUint16 primType;
@@ -166,7 +166,7 @@ static void CsrWifiRouterTransportSerialiseAndSend(CsrUint16 primType, void* msg
     CsrSize msgSize;
     CsrSize encodeBufferLen = 0;
     CsrSize offset = 0;
-    CsrUint8* encodeBuffer;
+    u8* encodeBuffer;
 
     unifi_trace(drvpriv, UDBG4, "CsrWifiRouterTransportSerialiseAndSend: primType=0x%.4X, msgType=0x%.4X\n",
                 primType, evt->type);
diff --git a/drivers/staging/csr/csr_wifi_serialize_primitive_types.c b/drivers/staging/csr/csr_wifi_serialize_primitive_types.c
index 155bf656256..0e5e20116e0 100644
--- a/drivers/staging/csr/csr_wifi_serialize_primitive_types.c
+++ b/drivers/staging/csr/csr_wifi_serialize_primitive_types.c
@@ -16,7 +16,7 @@
 #include "csr_wifi_msgconv.h"
 #include "csr_wifi_lib.h"
 
-void CsrUint24Des(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint24Des(CsrUint32 *v, u8 *buffer, CsrSize *offset)
 {
     CsrUint32 val;
 
@@ -30,7 +30,7 @@ void CsrUint24Des(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
 
 
 /* Big endian :e.g WSC, TCLAS */
-void CsrUint16DesBigEndian(CsrUint16 *v, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint16DesBigEndian(CsrUint16 *v, u8 *buffer, CsrSize *offset)
 {
     CsrUint16 val;
 
@@ -41,7 +41,7 @@ void CsrUint16DesBigEndian(CsrUint16 *v, CsrUint8 *buffer, CsrSize *offset)
 }
 
 
-void CsrUint24DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint24DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset)
 {
     CsrUint32 val;
 
@@ -54,7 +54,7 @@ void CsrUint24DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
 }
 
 
-void CsrUint32DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
+void CsrUint32DesBigEndian(CsrUint32 *v, u8 *buffer, CsrSize *offset)
 {
     CsrUint32 val;
 
@@ -68,42 +68,42 @@ void CsrUint32DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
 }
 
 
-void CsrUint24Ser(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
+void CsrUint24Ser(u8 *ptr, CsrSize *len, CsrUint32 v)
 {
-    ptr[(*len) + 2] = (CsrUint8)((v & 0x00ff0000) >> 16);
-    ptr[(*len) + 1] = (CsrUint8)((v & 0x0000ff00) >> 8);
-    ptr[(*len)]     = (CsrUint8)((v & 0x000000ff));
+    ptr[(*len) + 2] = (u8)((v & 0x00ff0000) >> 16);
+    ptr[(*len) + 1] = (u8)((v & 0x0000ff00) >> 8);
+    ptr[(*len)]     = (u8)((v & 0x000000ff));
 
     *len += 3;
 }
 
 
 /* Big endian :e.g WSC, TCLAS */
-void CsrUint16SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint16 v)
+void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, CsrUint16 v)
 {
-    ptr[(*len)] = (CsrUint8)((v & 0xff00) >> 8);
-    ptr[(*len) + 1] = (CsrUint8)((v & 0x00ff));
+    ptr[(*len)] = (u8)((v & 0xff00) >> 8);
+    ptr[(*len) + 1] = (u8)((v & 0x00ff));
 
     *len += 2;
 }
 
 
-void CsrUint32SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
+void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v)
 {
-    ptr[(*len)] = (CsrUint8)((v & 0xff000000) >> 24);
-    ptr[(*len) + 1] = (CsrUint8)((v & 0x00ff0000) >> 16);
-    ptr[(*len) + 2] = (CsrUint8)((v & 0x0000ff00) >> 8);
-    ptr[(*len) + 3] = (CsrUint8)((v & 0x000000ff));
+    ptr[(*len)] = (u8)((v & 0xff000000) >> 24);
+    ptr[(*len) + 1] = (u8)((v & 0x00ff0000) >> 16);
+    ptr[(*len) + 2] = (u8)((v & 0x0000ff00) >> 8);
+    ptr[(*len) + 3] = (u8)((v & 0x000000ff));
 
     *len += 4;
 }
 
 
-void CsrUint24SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
+void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, CsrUint32 v)
 {
-    ptr[(*len)] = (CsrUint8)((v & 0x00ff0000) >> 16);
-    ptr[(*len) + 1] = (CsrUint8)((v & 0x0000ff00) >> 8);
-    ptr[(*len) + 2] = (CsrUint8)((v & 0x000000ff));
+    ptr[(*len)] = (u8)((v & 0x00ff0000) >> 16);
+    ptr[(*len) + 1] = (u8)((v & 0x0000ff00) >> 8);
+    ptr[(*len) + 2] = (u8)((v & 0x000000ff));
 
     *len += 3;
 }
@@ -115,7 +115,7 @@ CsrSize CsrWifiEventSizeof(void *msg)
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventSizeof);
 
-CsrUint8* CsrWifiEventSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *)msg;
     *len = 0;
@@ -124,7 +124,7 @@ CsrUint8* CsrWifiEventSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventSer);
 
-void* CsrWifiEventDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiEventDes(u8 *buffer, CsrSize length)
 {
     CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *) CsrPmemAlloc(sizeof(CsrWifiFsmEvent));
     CsrSize offset = 0;
@@ -140,7 +140,7 @@ CsrSize CsrWifiEventCsrUint8Sizeof(void *msg)
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Sizeof);
 
-CsrUint8* CsrWifiEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *)msg;
     *len = 0;
@@ -151,7 +151,7 @@ CsrUint8* CsrWifiEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Ser);
 
 
-void* CsrWifiEventCsrUint8Des(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint8Des(u8 *buffer, CsrSize length)
 {
     CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint8));
 
@@ -171,7 +171,7 @@ CsrSize CsrWifiEventCsrUint16Sizeof(void *msg)
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Sizeof);
 
 
-CsrUint8* CsrWifiEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *)msg;
     *len = 0;
@@ -181,7 +181,7 @@ CsrUint8* CsrWifiEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Ser);
 
-void* CsrWifiEventCsrUint16Des(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint16Des(u8 *buffer, CsrSize length)
 {
     CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16));
 
@@ -200,7 +200,7 @@ CsrSize CsrWifiEventCsrUint32Sizeof(void *msg)
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Sizeof);
 
-CsrUint8* CsrWifiEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *)msg;
     *len = 0;
@@ -211,7 +211,7 @@ CsrUint8* CsrWifiEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Ser);
 
 
-void* CsrWifiEventCsrUint32Des(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint32Des(u8 *buffer, CsrSize length)
 {
     CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint32));
 
@@ -229,7 +229,7 @@ CsrSize CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg)
 }
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Sizeof);
 
-CsrUint8* CsrWifiEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *)msg;
     *len = 0;
@@ -241,7 +241,7 @@ CsrUint8* CsrWifiEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *ms
 EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Ser);
 
 
-void* CsrWifiEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length)
 {
     CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16CsrUint8));
 
diff --git a/drivers/staging/csr/csr_wifi_sme_ap_prim.h b/drivers/staging/csr/csr_wifi_sme_ap_prim.h
index 41594395c65..be275afa01b 100644
--- a/drivers/staging/csr/csr_wifi_sme_ap_prim.h
+++ b/drivers/staging/csr/csr_wifi_sme_ap_prim.h
@@ -48,7 +48,7 @@ typedef CsrPrim CsrWifiSmeApPrim;
     CSR_WIFI_AP_ACCESS_TYPE_DENY  - Disallow if MAC address is from the list
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApAccessType;
+typedef u8 CsrWifiSmeApAccessType;
 #define CSR_WIFI_AP_ACCESS_TYPE_NONE    ((CsrWifiSmeApAccessType) 0x00)
 #define CSR_WIFI_AP_ACCESS_TYPE_ALLOW   ((CsrWifiSmeApAccessType) 0x01)
 #define CSR_WIFI_AP_ACCESS_TYPE_DENY    ((CsrWifiSmeApAccessType) 0x02)
@@ -67,7 +67,7 @@ typedef CsrUint8 CsrWifiSmeApAccessType;
     CSR_WIFI_SME_AUTH_WAPIPSK     - WAPI-PSK Support
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApAuthSupport;
+typedef u8 CsrWifiSmeApAuthSupport;
 #define CSR_WIFI_SME_RSN_AUTH_WPAPSK    ((CsrWifiSmeApAuthSupport) 0x01)
 #define CSR_WIFI_SME_RSN_AUTH_WPA2PSK   ((CsrWifiSmeApAuthSupport) 0x02)
 #define CSR_WIFI_SME_AUTH_WAPIPSK       ((CsrWifiSmeApAuthSupport) 0x04)
@@ -90,7 +90,7 @@ typedef CsrUint8 CsrWifiSmeApAuthSupport;
                    - WEP authentication. This can be either open or shared key
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApAuthType;
+typedef u8 CsrWifiSmeApAuthType;
 #define CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM   ((CsrWifiSmeApAuthType) 0x00)
 #define CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL      ((CsrWifiSmeApAuthType) 0x01)
 #define CSR_WIFI_SME_AP_AUTH_TYPE_WEP           ((CsrWifiSmeApAuthType) 0x02)
@@ -108,7 +108,7 @@ typedef CsrUint8 CsrWifiSmeApAuthType;
     CSR_WIFI_AP_DIRECTION_ORIGINATOR - Originator
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApDirection;
+typedef u8 CsrWifiSmeApDirection;
 #define CSR_WIFI_AP_DIRECTION_RECEIPIENT   ((CsrWifiSmeApDirection) 0x00)
 #define CSR_WIFI_AP_DIRECTION_ORIGINATOR   ((CsrWifiSmeApDirection) 0x01)
 
@@ -128,7 +128,7 @@ typedef CsrUint8 CsrWifiSmeApDirection;
     CSR_WIFI_SME_AP_PHY_SUPPORT_N - 802.11n
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApPhySupport;
+typedef u8 CsrWifiSmeApPhySupport;
 #define CSR_WIFI_SME_AP_PHY_SUPPORT_A   ((CsrWifiSmeApPhySupport) 0x01)
 #define CSR_WIFI_SME_AP_PHY_SUPPORT_B   ((CsrWifiSmeApPhySupport) 0x02)
 #define CSR_WIFI_SME_AP_PHY_SUPPORT_G   ((CsrWifiSmeApPhySupport) 0x04)
@@ -147,7 +147,7 @@ typedef CsrUint8 CsrWifiSmeApPhySupport;
     CSR_WIFI_AP_TYPE_P2P    - P2P Group Owner(GO)
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApType;
+typedef u8 CsrWifiSmeApType;
 #define CSR_WIFI_AP_TYPE_LEGACY   ((CsrWifiSmeApType) 0x00)
 #define CSR_WIFI_AP_TYPE_P2P      ((CsrWifiSmeApType) 0x01)
 
@@ -161,7 +161,7 @@ typedef CsrUint8 CsrWifiSmeApType;
     See CsrWifiSmeApAuthSupport for bit definitions
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApAuthSupportMask;
+typedef u8 CsrWifiSmeApAuthSupportMask;
 /*******************************************************************************
 
   NAME
@@ -171,7 +171,7 @@ typedef CsrUint8 CsrWifiSmeApAuthSupportMask;
     Mask type for use with the values defined by CsrWifiSmeApPhySupport
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeApPhySupportMask;
+typedef u8 CsrWifiSmeApPhySupportMask;
 /*******************************************************************************
 
   NAME
@@ -250,9 +250,9 @@ typedef struct
 {
     CsrBool  greenfieldSupported;
     CsrBool  shortGi20MHz;
-    CsrUint8 rxStbc;
+    u8 rxStbc;
     CsrBool  rifsModeAllowed;
-    CsrUint8 htProtection;
+    u8 htProtection;
     CsrBool  dualCtsProtection;
 } CsrWifiSmeApHtParams;
 
@@ -271,9 +271,9 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8  operatingClass;
-    CsrUint8  operatingChannelCount;
-    CsrUint8 *operatingChannel;
+    u8  operatingClass;
+    u8  operatingChannelCount;
+    u8 *operatingChannel;
 } CsrWifiSmeApP2pOperatingChanEntry;
 
 /*******************************************************************************
@@ -292,8 +292,8 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8                           country[3];
-    CsrUint8                           channelEntryListCount;
+    u8                           country[3];
+    u8                           channelEntryListCount;
     CsrWifiSmeApP2pOperatingChanEntry *channelEntryList;
 } CsrWifiSmeApP2pOperatingChanList;
 
@@ -337,7 +337,7 @@ typedef struct
 typedef struct
 {
     CsrWifiMacAddress     peerMacAddress;
-    CsrUint8              tid;
+    u8              tid;
     CsrWifiSmeApDirection direction;
 } CsrWifiSmeApBaSession;
 
@@ -384,10 +384,10 @@ typedef struct
 {
     CsrWifiSmeApPhySupportMask  phySupportedBitmap;
     CsrUint16                   beaconInterval;
-    CsrUint8                    dtimPeriod;
+    u8                    dtimPeriod;
     CsrUint16                   maxListenInterval;
-    CsrUint8                    supportedRatesCount;
-    CsrUint8                    supportedRates[20];
+    u8                    supportedRatesCount;
+    u8                    supportedRates[20];
     CsrWifiSmePreambleType      preamble;
     CsrBool                     shortSlotTimeEnabled;
     CsrWifiSmeCtsProtectionType ctsProtectionType;
@@ -395,7 +395,7 @@ typedef struct
     CsrWifiSmeWmmAcParams       wmmApParams[4];
     CsrWifiSmeWmmAcParams       wmmApBcParams[4];
     CsrWifiSmeApAccessType      accessType;
-    CsrUint8                    macAddressListCount;
+    u8                    macAddressListCount;
     CsrWifiMacAddress          *macAddressList;
     CsrWifiSmeApHtParams        apHtParams;
 } CsrWifiSmeApMacConfig;
@@ -436,7 +436,7 @@ typedef struct
     CsrWifiSmeP2pGroupCapabilityMask groupCapability;
     CsrWifiSmeApP2pOperatingChanList operatingChanList;
     CsrBool                          opPsEnabled;
-    CsrUint8                         ctWindow;
+    u8                         ctWindow;
     CsrWifiSmeP2pNoaConfigMethod     noaConfigMethod;
     CsrBool                          allowNoaWithNonP2pDevices;
 } CsrWifiSmeApP2pGoConfig;
@@ -551,13 +551,13 @@ typedef struct
 {
     CsrWifiFsmEvent         common;
     CsrUint16               interfaceTag;
-    CsrUint8                initialPresence;
+    u8                initialPresence;
     CsrWifiSmeApType        apType;
     CsrBool                 cloakSsid;
     CsrWifiSsid             ssid;
     CsrWifiSmeRadioIF       ifIndex;
-    CsrUint8                channel;
-    CsrUint8                maxConnections;
+    u8                channel;
+    u8                maxConnections;
     CsrWifiSmeApSecConfig   apCredentials;
     CsrWifiSmeApMacConfig   smeApConfig;
     CsrWifiSmeApP2pGoConfig p2pGoParam;
@@ -764,7 +764,7 @@ typedef struct
     CsrUint16       interfaceTag;
     CsrResult       status;
     CsrUint16       secIeLength;
-    CsrUint8       *secIe;
+    u8       *secIe;
 } CsrWifiSmeApBeaconingStartCfm;
 
 /*******************************************************************************
@@ -822,9 +822,9 @@ typedef struct
     CsrWifiSmeIEEE80211Reason disassocReason;
     CsrWifiSmeIEEE80211Reason deauthReason;
     CsrWifiSmeWpsRegistration WpsRegistration;
-    CsrUint8                  secIeLength;
-    CsrUint8                 *secIe;
-    CsrUint8                  groupKeyId;
+    u8                  secIeLength;
+    u8                 *secIe;
+    u8                  groupKeyId;
     CsrUint16                 seqNumber[8];
 } CsrWifiSmeApStaNotifyInd;
 
diff --git a/drivers/staging/csr/csr_wifi_sme_lib.h b/drivers/staging/csr/csr_wifi_sme_lib.h
index 67dcb48448c..63ac5dfcf28 100644
--- a/drivers/staging/csr/csr_wifi_sme_lib.h
+++ b/drivers/staging/csr/csr_wifi_sme_lib.h
@@ -1809,7 +1809,7 @@ extern const CsrCharString *CsrWifiSmeDownstreamPrimNames[CSR_WIFI_SME_PRIM_DOWN
     CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_CFM, dst__, src__); \
     msg__->status = (status__); \
     msg__->numInterfaces = (numInterfaces__); \
-    CsrMemCpy(msg__->capBitmap, (capBitmap__), sizeof(CsrUint8) * 2);
+    CsrMemCpy(msg__->capBitmap, (capBitmap__), sizeof(u8) * 2);
 
 #define CsrWifiSmeInterfaceCapabilityGetCfmSendTo(dst__, src__, status__, numInterfaces__, capBitmap__) \
     { \
diff --git a/drivers/staging/csr/csr_wifi_sme_prim.h b/drivers/staging/csr/csr_wifi_sme_prim.h
index 8ffa50a6c04..c9734a7339f 100644
--- a/drivers/staging/csr/csr_wifi_sme_prim.h
+++ b/drivers/staging/csr/csr_wifi_sme_prim.h
@@ -48,7 +48,7 @@ typedef CsrPrim CsrWifiSmePrim;
                    - Automatic
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSme80211NetworkType;
+typedef u8 CsrWifiSme80211NetworkType;
 #define CSR_WIFI_SME_80211_NETWORK_TYPE_DS       ((CsrWifiSme80211NetworkType) 0x00)
 #define CSR_WIFI_SME_80211_NETWORK_TYPE_OFDM24   ((CsrWifiSme80211NetworkType) 0x01)
 #define CSR_WIFI_SME_80211_NETWORK_TYPE_OFDM5    ((CsrWifiSme80211NetworkType) 0x02)
@@ -70,7 +70,7 @@ typedef CsrUint8 CsrWifiSme80211NetworkType;
                    - Privacy mode is disabled
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSme80211PrivacyMode;
+typedef u8 CsrWifiSme80211PrivacyMode;
 #define CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED   ((CsrWifiSme80211PrivacyMode) 0x00)
 #define CSR_WIFI_SME_80211_PRIVACY_MODE_ENABLED    ((CsrWifiSme80211PrivacyMode) 0x01)
 
@@ -104,7 +104,7 @@ typedef CsrUint8 CsrWifiSme80211PrivacyMode;
                      network
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSme80211dTrustLevel;
+typedef u8 CsrWifiSme80211dTrustLevel;
 #define CSR_WIFI_SME_80211D_TRUST_LEVEL_STRICT     ((CsrWifiSme80211dTrustLevel) 0x01)
 #define CSR_WIFI_SME_80211D_TRUST_LEVEL_ADJUNCT    ((CsrWifiSme80211dTrustLevel) 0x02)
 #define CSR_WIFI_SME_80211D_TRUST_LEVEL_BSS        ((CsrWifiSme80211dTrustLevel) 0x03)
@@ -125,7 +125,7 @@ typedef CsrUint8 CsrWifiSme80211dTrustLevel;
     CSR_WIFI_SME_AMP_INACTIVE - AMP INACTIVE
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeAmpStatus;
+typedef u8 CsrWifiSmeAmpStatus;
 #define CSR_WIFI_SME_AMP_ACTIVE     ((CsrWifiSmeAmpStatus) 0x00)
 #define CSR_WIFI_SME_AMP_INACTIVE   ((CsrWifiSmeAmpStatus) 0x01)
 
@@ -192,7 +192,7 @@ typedef CsrUint16 CsrWifiSmeAuthMode;
                    - Not connected
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeBasicUsability;
+typedef u8 CsrWifiSmeBasicUsability;
 #define CSR_WIFI_SME_BASIC_USABILITY_UNUSABLE        ((CsrWifiSmeBasicUsability) 0x00)
 #define CSR_WIFI_SME_BASIC_USABILITY_POOR            ((CsrWifiSmeBasicUsability) 0x01)
 #define CSR_WIFI_SME_BASIC_USABILITY_SATISFACTORY    ((CsrWifiSmeBasicUsability) 0x02)
@@ -217,7 +217,7 @@ typedef CsrUint8 CsrWifiSmeBasicUsability;
                    - Specifies P2P
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeBssType;
+typedef u8 CsrWifiSmeBssType;
 #define CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE   ((CsrWifiSmeBssType) 0x00)
 #define CSR_WIFI_SME_BSS_TYPE_ADHOC            ((CsrWifiSmeBssType) 0x01)
 #define CSR_WIFI_SME_BSS_TYPE_ANY_BSS          ((CsrWifiSmeBssType) 0x02)
@@ -243,7 +243,7 @@ typedef CsrUint8 CsrWifiSmeBssType;
                    - Packet Traffic Arbitrator coexistence signalling
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeCoexScheme;
+typedef u8 CsrWifiSmeCoexScheme;
 #define CSR_WIFI_SME_COEX_SCHEME_DISABLED      ((CsrWifiSmeCoexScheme) 0x00)
 #define CSR_WIFI_SME_COEX_SCHEME_CSR           ((CsrWifiSmeCoexScheme) 0x01)
 #define CSR_WIFI_SME_COEX_SCHEME_CSR_CHANNEL   ((CsrWifiSmeCoexScheme) 0x02)
@@ -275,7 +275,7 @@ typedef CsrUint8 CsrWifiSmeCoexScheme;
                      application has sent CSR_WIFI_SME_WIFI_OFF_REQ
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeControlIndication;
+typedef u8 CsrWifiSmeControlIndication;
 #define CSR_WIFI_SME_CONTROL_INDICATION_ERROR            ((CsrWifiSmeControlIndication) 0x01)
 #define CSR_WIFI_SME_CONTROL_INDICATION_EXIT             ((CsrWifiSmeControlIndication) 0x02)
 #define CSR_WIFI_SME_CONTROL_INDICATION_USER_REQUESTED   ((CsrWifiSmeControlIndication) 0x03)
@@ -304,7 +304,7 @@ typedef CsrUint8 CsrWifiSmeControlIndication;
                      this option specifies the same behaviour as AUTOMATIC
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeCtsProtectionType;
+typedef u8 CsrWifiSmeCtsProtectionType;
 #define CSR_WIFI_SME_CTS_PROTECTION_AUTOMATIC           ((CsrWifiSmeCtsProtectionType) 0x00)
 #define CSR_WIFI_SME_CTS_PROTECTION_FORCE_ENABLED       ((CsrWifiSmeCtsProtectionType) 0x01)
 #define CSR_WIFI_SME_CTS_PROTECTION_FORCE_DISABLED      ((CsrWifiSmeCtsProtectionType) 0x02)
@@ -328,7 +328,7 @@ typedef CsrUint8 CsrWifiSmeCtsProtectionType;
                      CURRENTLY NOT SUPPORTED
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeD3AutoScanMode;
+typedef u8 CsrWifiSmeD3AutoScanMode;
 #define CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSON     ((CsrWifiSmeD3AutoScanMode) 0x00)
 #define CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSOFF    ((CsrWifiSmeD3AutoScanMode) 0x01)
 #define CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSAUTO   ((CsrWifiSmeD3AutoScanMode) 0x02)
@@ -396,7 +396,7 @@ typedef CsrUint16 CsrWifiSmeEncryption;
                    - Preformated IEEE 802.11 header for user plane
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeFirmwareDriverInterface;
+typedef u8 CsrWifiSmeFirmwareDriverInterface;
 #define CSR_WIFI_SME_FIRMWARE_DRIVER_INTERFACE_UNIT_DATA_INTERFACE   ((CsrWifiSmeFirmwareDriverInterface) 0x00)
 #define CSR_WIFI_SME_FIRMWARE_DRIVER_INTERFACE_PACKET_INTERFACE      ((CsrWifiSmeFirmwareDriverInterface) 0x01)
 
@@ -417,7 +417,7 @@ typedef CsrUint8 CsrWifiSmeFirmwareDriverInterface;
                    - For future use.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeHostPowerMode;
+typedef u8 CsrWifiSmeHostPowerMode;
 #define CSR_WIFI_SME_HOST_POWER_MODE_ACTIVE            ((CsrWifiSmeHostPowerMode) 0x00)
 #define CSR_WIFI_SME_HOST_POWER_MODE_POWER_SAVE        ((CsrWifiSmeHostPowerMode) 0x01)
 #define CSR_WIFI_SME_HOST_POWER_MODE_FULL_POWER_SAVE   ((CsrWifiSmeHostPowerMode) 0x02)
@@ -866,7 +866,7 @@ typedef CsrUint32 CsrWifiSmeIndications;
     CSR_WIFI_SME_KEY_TYPE_CCKM     - Key for Cisco Centralized Key Management
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeKeyType;
+typedef u8 CsrWifiSmeKeyType;
 #define CSR_WIFI_SME_KEY_TYPE_GROUP      ((CsrWifiSmeKeyType) 0x00)
 #define CSR_WIFI_SME_KEY_TYPE_PAIRWISE   ((CsrWifiSmeKeyType) 0x01)
 #define CSR_WIFI_SME_KEY_TYPE_STAKEY     ((CsrWifiSmeKeyType) 0x02)
@@ -891,7 +891,7 @@ typedef CsrUint8 CsrWifiSmeKeyType;
     CSR_WIFI_SME_LIST_ACTION_FLUSH  - Remove all items
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeListAction;
+typedef u8 CsrWifiSmeListAction;
 #define CSR_WIFI_SME_LIST_ACTION_GET      ((CsrWifiSmeListAction) 0x00)
 #define CSR_WIFI_SME_LIST_ACTION_ADD      ((CsrWifiSmeListAction) 0x01)
 #define CSR_WIFI_SME_LIST_ACTION_REMOVE   ((CsrWifiSmeListAction) 0x02)
@@ -933,7 +933,7 @@ typedef CsrUint8 CsrWifiSmeListAction;
                      station has disconnected from the AP
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeMediaStatus;
+typedef u8 CsrWifiSmeMediaStatus;
 #define CSR_WIFI_SME_MEDIA_STATUS_CONNECTED      ((CsrWifiSmeMediaStatus) 0x00)
 #define CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED   ((CsrWifiSmeMediaStatus) 0x01)
 
@@ -966,7 +966,7 @@ typedef CsrUint8 CsrWifiSmeMediaStatus;
                      otherwise.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pCapability;
+typedef u8 CsrWifiSmeP2pCapability;
 #define CSR_WIFI_SME_P2P_SERVICE_DISCOVERY_CAPABILITY        ((CsrWifiSmeP2pCapability) 0x01)
 #define CSR_WIFI_SME_P2P_CLIENT_DISCOVERABILITY_CAPABILITY   ((CsrWifiSmeP2pCapability) 0x02)
 #define CSR_WIFI_SME_P2P_CONCURRENT_OPERATION_CAPABILITY     ((CsrWifiSmeP2pCapability) 0x04)
@@ -995,7 +995,7 @@ typedef CsrUint8 CsrWifiSmeP2pCapability;
                    - Support of persistent reconnect
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pGroupCapability;
+typedef u8 CsrWifiSmeP2pGroupCapability;
 #define CSR_WIFI_P2P_GRP_CAP_GO                     ((CsrWifiSmeP2pGroupCapability) 0x01)
 #define CSR_WIFI_P2P_GRP_CAP_PERSISTENT             ((CsrWifiSmeP2pGroupCapability) 0x02)
 #define CSR_WIFI_P2P_GRP_CAP_INTRABSS_DIST          ((CsrWifiSmeP2pGroupCapability) 0x08)
@@ -1016,7 +1016,7 @@ typedef CsrUint8 CsrWifiSmeP2pGroupCapability;
     CSR_WIFI_P2P_NOA_USER_DEFINED - NOA as specified by the user
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pNoaConfigMethod;
+typedef u8 CsrWifiSmeP2pNoaConfigMethod;
 #define CSR_WIFI_P2P_NOA_NONE           ((CsrWifiSmeP2pNoaConfigMethod) 0x00)
 #define CSR_WIFI_P2P_NOA_AUTONOMOUS     ((CsrWifiSmeP2pNoaConfigMethod) 0x01)
 #define CSR_WIFI_P2P_NOA_USER_DEFINED   ((CsrWifiSmeP2pNoaConfigMethod) 0x02)
@@ -1038,7 +1038,7 @@ typedef CsrUint8 CsrWifiSmeP2pNoaConfigMethod;
                                        within a P2P Group
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pRole;
+typedef u8 CsrWifiSmeP2pRole;
 #define CSR_WIFI_SME_P2P_ROLE_NONE         ((CsrWifiSmeP2pRole) 0x00)
 #define CSR_WIFI_SME_P2P_ROLE_STANDALONE   ((CsrWifiSmeP2pRole) 0x01)
 #define CSR_WIFI_SME_P2P_ROLE_GO           ((CsrWifiSmeP2pRole) 0x02)
@@ -1082,7 +1082,7 @@ typedef CsrUint8 CsrWifiSmeP2pRole;
                    - Fail; Status Reserved
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pStatus;
+typedef u8 CsrWifiSmeP2pStatus;
 #define CSR_WIFI_SME_P2P_STATUS_SUCCESS                              ((CsrWifiSmeP2pStatus) 0x00)
 #define CSR_WIFI_SME_P2P_STATUS_FAIL_INFO_UNAVAILABLE                ((CsrWifiSmeP2pStatus) 0x01)
 #define CSR_WIFI_SME_P2P_STATUS_FAIL_INCOMPATIBLE_PARAM              ((CsrWifiSmeP2pStatus) 0x02)
@@ -1115,7 +1115,7 @@ typedef CsrUint8 CsrWifiSmeP2pStatus;
                      match at least one of the specified TCLAS IEs.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmePacketFilterMode;
+typedef u8 CsrWifiSmePacketFilterMode;
 #define CSR_WIFI_SME_PACKET_FILTER_MODE_OPT_OUT   ((CsrWifiSmePacketFilterMode) 0x00)
 #define CSR_WIFI_SME_PACKET_FILTER_MODE_OPT_IN    ((CsrWifiSmePacketFilterMode) 0x03)
 
@@ -1142,7 +1142,7 @@ typedef CsrUint8 CsrWifiSmePacketFilterMode;
                                          analysis
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmePowerSaveLevel;
+typedef u8 CsrWifiSmePowerSaveLevel;
 #define CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW    ((CsrWifiSmePowerSaveLevel) 0x00)
 #define CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH   ((CsrWifiSmePowerSaveLevel) 0x01)
 #define CSR_WIFI_SME_POWER_SAVE_LEVEL_MED    ((CsrWifiSmePowerSaveLevel) 0x02)
@@ -1161,7 +1161,7 @@ typedef CsrUint8 CsrWifiSmePowerSaveLevel;
     CSR_WIFI_SME_USE_SHORT_PREAMBLE - Use short PPDU format
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmePreambleType;
+typedef u8 CsrWifiSmePreambleType;
 #define CSR_WIFI_SME_USE_LONG_PREAMBLE    ((CsrWifiSmePreambleType) 0x00)
 #define CSR_WIFI_SME_USE_SHORT_PREAMBLE   ((CsrWifiSmePreambleType) 0x01)
 
@@ -1179,7 +1179,7 @@ typedef CsrUint8 CsrWifiSmePreambleType;
     CSR_WIFI_SME_RADIO_IF_BOTH    - Future use: currently not supported
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeRadioIF;
+typedef u8 CsrWifiSmeRadioIF;
 #define CSR_WIFI_SME_RADIO_IF_GHZ_2_4   ((CsrWifiSmeRadioIF) 0x01)
 #define CSR_WIFI_SME_RADIO_IF_GHZ_5_0   ((CsrWifiSmeRadioIF) 0x02)
 #define CSR_WIFI_SME_RADIO_IF_BOTH      ((CsrWifiSmeRadioIF) 0x03)
@@ -1217,7 +1217,7 @@ typedef CsrUint8 CsrWifiSmeRadioIF;
                    - See IEEE 802.11 Standard
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeRegulatoryDomain;
+typedef u8 CsrWifiSmeRegulatoryDomain;
 #define CSR_WIFI_SME_REGULATORY_DOMAIN_OTHER      ((CsrWifiSmeRegulatoryDomain) 0x00)
 #define CSR_WIFI_SME_REGULATORY_DOMAIN_FCC        ((CsrWifiSmeRegulatoryDomain) 0x10)
 #define CSR_WIFI_SME_REGULATORY_DOMAIN_IC         ((CsrWifiSmeRegulatoryDomain) 0x20)
@@ -1249,7 +1249,7 @@ typedef CsrUint8 CsrWifiSmeRegulatoryDomain;
                    - A better AP has been found
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeRoamReason;
+typedef u8 CsrWifiSmeRoamReason;
 #define CSR_WIFI_SME_ROAM_REASON_BEACONLOST        ((CsrWifiSmeRoamReason) 0x00)
 #define CSR_WIFI_SME_ROAM_REASON_DISASSOCIATED     ((CsrWifiSmeRoamReason) 0x01)
 #define CSR_WIFI_SME_ROAM_REASON_DEAUTHENTICATED   ((CsrWifiSmeRoamReason) 0x02)
@@ -1272,7 +1272,7 @@ typedef CsrUint8 CsrWifiSmeRoamReason;
                                      messages
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeScanType;
+typedef u8 CsrWifiSmeScanType;
 #define CSR_WIFI_SME_SCAN_TYPE_ALL       ((CsrWifiSmeScanType) 0x00)
 #define CSR_WIFI_SME_SCAN_TYPE_ACTIVE    ((CsrWifiSmeScanType) 0x01)
 #define CSR_WIFI_SME_SCAN_TYPE_PASSIVE   ((CsrWifiSmeScanType) 0x02)
@@ -1305,7 +1305,7 @@ typedef CsrUint8 CsrWifiSmeScanType;
                      received each second in either direction
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeTrafficType;
+typedef u8 CsrWifiSmeTrafficType;
 #define CSR_WIFI_SME_TRAFFIC_TYPE_OCCASIONAL   ((CsrWifiSmeTrafficType) 0x00)
 #define CSR_WIFI_SME_TRAFFIC_TYPE_BURSTY       ((CsrWifiSmeTrafficType) 0x01)
 #define CSR_WIFI_SME_TRAFFIC_TYPE_PERIODIC     ((CsrWifiSmeTrafficType) 0x02)
@@ -1329,7 +1329,7 @@ typedef CsrUint8 CsrWifiSmeTrafficType;
                    - Voice traffic TSPEC
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeTspecCtrl;
+typedef u8 CsrWifiSmeTspecCtrl;
 #define CSR_WIFI_SME_TSPEC_CTRL_STRICT           ((CsrWifiSmeTspecCtrl) 0x01)
 #define CSR_WIFI_SME_TSPEC_CTRL_CCX_SIGNALLING   ((CsrWifiSmeTspecCtrl) 0x02)
 #define CSR_WIFI_SME_TSPEC_CTRL_CCX_VOICE        ((CsrWifiSmeTspecCtrl) 0x04)
@@ -1375,7 +1375,7 @@ typedef CsrUint8 CsrWifiSmeTspecCtrl;
                    - The AP has deleted the TSPEC
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeTspecResultCode;
+typedef u8 CsrWifiSmeTspecResultCode;
 #define CSR_WIFI_SME_TSPEC_RESULT_SUCCESS                           ((CsrWifiSmeTspecResultCode) 0x00)
 #define CSR_WIFI_SME_TSPEC_RESULT_UNSPECIFIED_QOS_FAILURE           ((CsrWifiSmeTspecResultCode) 0x01)
 #define CSR_WIFI_SME_TSPEC_RESULT_FAILURE                           ((CsrWifiSmeTspecResultCode) 0x02)
@@ -1405,7 +1405,7 @@ typedef CsrUint8 CsrWifiSmeTspecResultCode;
     CSR_WIFI_SME_WEP_AUTH_MODE_SHARED - Shared-key WEP enabled network.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWepAuthMode;
+typedef u8 CsrWifiSmeWepAuthMode;
 #define CSR_WIFI_SME_WEP_AUTH_MODE_OPEN     ((CsrWifiSmeWepAuthMode) 0x00)
 #define CSR_WIFI_SME_WEP_AUTH_MODE_SHARED   ((CsrWifiSmeWepAuthMode) 0x01)
 
@@ -1424,7 +1424,7 @@ typedef CsrUint8 CsrWifiSmeWepAuthMode;
                    - WEP 128 credential
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWepCredentialType;
+typedef u8 CsrWifiSmeWepCredentialType;
 #define CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64    ((CsrWifiSmeWepCredentialType) 0x00)
 #define CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128   ((CsrWifiSmeWepCredentialType) 0x01)
 
@@ -1445,7 +1445,7 @@ typedef CsrUint8 CsrWifiSmeWepCredentialType;
                                        available WMM features.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWmmMode;
+typedef u8 CsrWifiSmeWmmMode;
 #define CSR_WIFI_SME_WMM_MODE_DISABLED     ((CsrWifiSmeWmmMode) 0x00)
 #define CSR_WIFI_SME_WMM_MODE_AC_ENABLED   ((CsrWifiSmeWmmMode) 0x01)
 #define CSR_WIFI_SME_WMM_MODE_PS_ENABLED   ((CsrWifiSmeWmmMode) 0x02)
@@ -1491,7 +1491,7 @@ typedef CsrUint8 CsrWifiSmeWmmMode;
                      and MMPDUs) per USP
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWmmQosInfo;
+typedef u8 CsrWifiSmeWmmQosInfo;
 #define CSR_WIFI_SME_WMM_QOS_INFO_AC_MAX_SP_ALL    ((CsrWifiSmeWmmQosInfo) 0x00)
 #define CSR_WIFI_SME_WMM_QOS_INFO_AC_VO            ((CsrWifiSmeWmmQosInfo) 0x01)
 #define CSR_WIFI_SME_WMM_QOS_INFO_AC_VI            ((CsrWifiSmeWmmQosInfo) 0x02)
@@ -1584,7 +1584,7 @@ typedef CsrUint16 CsrWifiSmeWpsConfigType;
                    - Others.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWpsDeviceCategory;
+typedef u8 CsrWifiSmeWpsDeviceCategory;
 #define CSR_WIFI_SME_WPS_CATEGORY_UNSPECIFIED      ((CsrWifiSmeWpsDeviceCategory) 0x00)
 #define CSR_WIFI_SME_WPS_CATEGORY_COMPUTER         ((CsrWifiSmeWpsDeviceCategory) 0x01)
 #define CSR_WIFI_SME_WPS_CATEGORY_INPUT_DEV        ((CsrWifiSmeWpsDeviceCategory) 0x02)
@@ -1726,7 +1726,7 @@ typedef CsrUint8 CsrWifiSmeWpsDeviceCategory;
                    - Bar code reader.
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWpsDeviceSubCategory;
+typedef u8 CsrWifiSmeWpsDeviceSubCategory;
 #define CSR_WIFI_SME_WPS_SUB_CATEGORY_UNSPECIFIED             ((CsrWifiSmeWpsDeviceSubCategory) 0x00)
 #define CSR_WIFI_SME_WPS_STORAGE_SUB_CATEGORY_NAS             ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
 #define CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_PRNTR              ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
@@ -1827,7 +1827,7 @@ typedef CsrUint16 CsrWifiSmeWpsDpid;
     CSR_WIFI_SME_WPS_REG_UNKNOWN      - No encryption set
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWpsRegistration;
+typedef u8 CsrWifiSmeWpsRegistration;
 #define CSR_WIFI_SME_WPS_REG_NOT_REQUIRED   ((CsrWifiSmeWpsRegistration) 0x00)
 #define CSR_WIFI_SME_WPS_REG_REQUIRED       ((CsrWifiSmeWpsRegistration) 0x01)
 #define CSR_WIFI_SME_WPS_REG_UNKNOWN        ((CsrWifiSmeWpsRegistration) 0x02)
@@ -1872,7 +1872,7 @@ typedef CsrUint32 CsrWifiSmeIndicationsMask;
     Mask type for use with the values defined by CsrWifiSmeP2pCapability
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pCapabilityMask;
+typedef u8 CsrWifiSmeP2pCapabilityMask;
 /*******************************************************************************
 
   NAME
@@ -1882,7 +1882,7 @@ typedef CsrUint8 CsrWifiSmeP2pCapabilityMask;
     Mask type for use with the values defined by CsrWifiSmeP2pGroupCapability
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeP2pGroupCapabilityMask;
+typedef u8 CsrWifiSmeP2pGroupCapabilityMask;
 /*******************************************************************************
 
   NAME
@@ -1892,7 +1892,7 @@ typedef CsrUint8 CsrWifiSmeP2pGroupCapabilityMask;
     Mask type for use with the values defined by CsrWifiSmeTspecCtrl
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeTspecCtrlMask;
+typedef u8 CsrWifiSmeTspecCtrlMask;
 /*******************************************************************************
 
   NAME
@@ -1902,7 +1902,7 @@ typedef CsrUint8 CsrWifiSmeTspecCtrlMask;
     Mask type for use with the values defined by CsrWifiSmeWmmMode
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWmmModeMask;
+typedef u8 CsrWifiSmeWmmModeMask;
 /*******************************************************************************
 
   NAME
@@ -1912,7 +1912,7 @@ typedef CsrUint8 CsrWifiSmeWmmModeMask;
     Mask type for use with the values defined by CsrWifiSmeWmmQosInfo
 
 *******************************************************************************/
-typedef CsrUint8 CsrWifiSmeWmmQosInfoMask;
+typedef u8 CsrWifiSmeWmmQosInfoMask;
 /*******************************************************************************
 
   NAME
@@ -1965,7 +1965,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8  listenChannel;
+    u8  listenChannel;
     CsrUint16 availabilityDuration;
     CsrUint16 avalabilityPeriod;
 } CsrWifiSmeAvailabilityConfig;
@@ -1987,9 +1987,9 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8 keepAliveTimeMs;
+    u8 keepAliveTimeMs;
     CsrBool  apRoamingEnabled;
-    CsrUint8 measurementsMask;
+    u8 measurementsMask;
     CsrBool  ccxRadioMgtEnabled;
 } CsrWifiSmeCcxConfig;
 
@@ -2125,8 +2125,8 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8  unifiTxDataRate;
-    CsrUint8  unifiRxDataRate;
+    u8  unifiTxDataRate;
+    u8  unifiRxDataRate;
     CsrUint32 dot11RetryCount;
     CsrUint32 dot11MultipleRetryCount;
     CsrUint32 dot11AckFailureCount;
@@ -2168,7 +2168,7 @@ typedef struct
 typedef struct
 {
     CsrUint16 length;
-    CsrUint8 *data;
+    u8 *data;
 } CsrWifiSmeDataBlock;
 
 /*******************************************************************************
@@ -2185,7 +2185,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8 empty;
+    u8 empty;
 } CsrWifiSmeEmpty;
 
 /*******************************************************************************
@@ -2232,7 +2232,7 @@ typedef struct
 typedef struct
 {
     CsrBool   unifiFixMaxTxDataRate;
-    CsrUint8  unifiFixTxDataRate;
+    u8  unifiFixTxDataRate;
     CsrUint16 dot11RtsThreshold;
     CsrUint16 dot11FragmentationThreshold;
     CsrUint16 dot11CurrentTxPowerLevel;
@@ -2254,7 +2254,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8  listenChannel;
+    u8  listenChannel;
     CsrUint16 availabilityDuration;
     CsrUint16 avalabilityPeriod;
 } CsrWifiSmeP2pProfileIdentity;
@@ -2275,7 +2275,7 @@ typedef struct
 typedef struct
 {
     CsrWifiMacAddress bssid;
-    CsrUint8          pmkid[16];
+    u8          pmkid[16];
 } CsrWifiSmePmkid;
 
 /*******************************************************************************
@@ -2313,7 +2313,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8         pmkidsCount;
+    u8         pmkidsCount;
     CsrWifiSmePmkid *pmkids;
 } CsrWifiSmePmkidList;
 
@@ -2342,7 +2342,7 @@ typedef struct
     CsrBool                    dot11MultiDomainCapabilityImplemented;
     CsrBool                    dot11MultiDomainCapabilityEnabled;
     CsrWifiSmeRegulatoryDomain currentRegulatoryDomain;
-    CsrUint8                   currentCountryCode[2];
+    u8                   currentCountryCode[2];
 } CsrWifiSmeRegulatoryDomainInfo;
 
 /*******************************************************************************
@@ -2424,7 +2424,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8 data[8];
+    u8 data[8];
 } CsrWifiSmeTsfTime;
 
 /*******************************************************************************
@@ -2485,9 +2485,9 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8  cwMin;
-    CsrUint8  cwMax;
-    CsrUint8  aifs;
+    u8  cwMin;
+    u8  cwMax;
+    u8  aifs;
     CsrUint16 txopLimit;
     CsrBool   admissionControlMandatory;
 } CsrWifiSmeWmmAcParams;
@@ -2506,7 +2506,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8 deviceDetails[8];
+    u8 deviceDetails[8];
 } CsrWifiSmeWpsDeviceType;
 
 /*******************************************************************************
@@ -2524,7 +2524,7 @@ typedef struct
 typedef struct
 {
     CsrBool  spportWps;
-    CsrUint8 deviceType;
+    u8 deviceType;
 } CsrWifiSmeWpsDeviceTypeCommon;
 
 /*******************************************************************************
@@ -2562,7 +2562,7 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8     cloakedSsidsCount;
+    u8     cloakedSsidsCount;
     CsrWifiSsid *cloakedSsids;
 } CsrWifiSmeCloakedSsidConfig;
 
@@ -2675,10 +2675,10 @@ typedef struct
     CsrWifiSmeAuthModeMask     authModeMask;
     CsrWifiSmeEncryptionMask   encryptionModeMask;
     CsrUint16                  mlmeAssociateReqInformationElementsLength;
-    CsrUint8                  *mlmeAssociateReqInformationElements;
+    u8                  *mlmeAssociateReqInformationElements;
     CsrWifiSmeWmmQosInfoMask   wmmQosInfo;
     CsrBool                    adhocJoinOnly;
-    CsrUint8                   adhocChannel;
+    u8                   adhocChannel;
 } CsrWifiSmeConnectionConfig;
 
 /*******************************************************************************
@@ -2748,7 +2748,7 @@ typedef struct
     CsrWifiSsid                ssid;
     CsrWifiMacAddress          bssid;
     CsrWifiSme80211NetworkType networkType80211;
-    CsrUint8                   channelNumber;
+    u8                   channelNumber;
     CsrUint16                  channelFrequency;
     CsrWifiSmeAuthMode         authMode;
     CsrWifiSmeEncryption       pairwiseCipher;
@@ -2758,23 +2758,23 @@ typedef struct
     CsrUint16                  beaconPeriodTu;
     CsrBool                    reassociation;
     CsrUint16                  beaconFrameLength;
-    CsrUint8                  *beaconFrame;
+    u8                  *beaconFrame;
     CsrUint16                  associationReqFrameLength;
-    CsrUint8                  *associationReqFrame;
+    u8                  *associationReqFrame;
     CsrUint16                  associationRspFrameLength;
-    CsrUint8                  *associationRspFrame;
+    u8                  *associationRspFrame;
     CsrUint16                  assocScanInfoElementsLength;
-    CsrUint8                  *assocScanInfoElements;
+    u8                  *assocScanInfoElements;
     CsrUint16                  assocReqCapabilities;
     CsrUint16                  assocReqListenIntervalTu;
     CsrWifiMacAddress          assocReqApAddress;
     CsrUint16                  assocReqInfoElementsLength;
-    CsrUint8                  *assocReqInfoElements;
+    u8                  *assocReqInfoElements;
     CsrWifiSmeIEEE80211Result  assocRspResult;
     CsrUint16                  assocRspCapabilityInfo;
     CsrUint16                  assocRspAssociationId;
     CsrUint16                  assocRspInfoElementsLength;
-    CsrUint8                  *assocRspInfoElements;
+    u8                  *assocRspInfoElements;
 } CsrWifiSmeConnectionInfo;
 
 /*******************************************************************************
@@ -2798,7 +2798,7 @@ typedef struct
 typedef struct
 {
     CsrWifiSme80211dTrustLevel        trustLevel;
-    CsrUint8                          countryCode[2];
+    u8                          countryCode[2];
     CsrWifiSmeFirmwareDriverInterface firmwareDriverInterface;
     CsrBool                           enableStrictDraftN;
 } CsrWifiSmeDeviceConfig;
@@ -2828,10 +2828,10 @@ typedef struct
     CsrWifiSmeWpsConfigTypeMask configMethods;
     CsrWifiSmeP2pCapabilityMask p2PDeviceCap;
     CsrWifiSmeWpsDeviceType     primDeviceType;
-    CsrUint8                    secondaryDeviceTypeCount;
+    u8                    secondaryDeviceTypeCount;
     CsrWifiSmeWpsDeviceType    *secDeviceType;
-    CsrUint8                    deviceName[32];
-    CsrUint8                    deviceNameLength;
+    u8                    deviceName[32];
+    u8                    deviceNameLength;
 } CsrWifiSmeDeviceInfo;
 
 /*******************************************************************************
@@ -2855,10 +2855,10 @@ typedef struct
 {
     CsrWifiMacAddress             p2pDeviceAddress;
     CsrWifiSmeWpsDeviceTypeCommon primaryDeviceType;
-    CsrUint8                      secondaryDeviceTypesCount;
-    CsrUint8                      secondaryDeviceTypes[10];
-    CsrUint8                      deviceNameLength;
-    CsrUint8                      deviceName[32];
+    u8                      secondaryDeviceTypesCount;
+    u8                      secondaryDeviceTypes[10];
+    u8                      deviceNameLength;
+    u8                      deviceName[32];
 } CsrWifiSmeDeviceInfoCommon;
 
 /*******************************************************************************
@@ -2924,13 +2924,13 @@ typedef struct
 typedef struct
 {
     CsrWifiSmeKeyType keyType;
-    CsrUint8          keyIndex;
+    u8          keyIndex;
     CsrBool           wepTxKey;
     CsrUint16         keyRsc[8];
     CsrBool           authenticator;
     CsrWifiMacAddress address;
-    CsrUint8          keyLength;
-    CsrUint8          key[32];
+    u8          keyLength;
+    u8          key[32];
 } CsrWifiSmeKey;
 
 /*******************************************************************************
@@ -2972,7 +2972,7 @@ typedef struct
 {
     CsrWifiSmeP2pGroupCapabilityMask groupCapability;
     CsrWifiMacAddress                p2pDeviceAddress;
-    CsrUint8                         p2pClientInfoCount;
+    u8                         p2pClientInfoCount;
     CsrWifiSmeP2pClientInfoType     *p2PClientInfo;
 } CsrWifiSmeP2pGroupInfo;
 
@@ -3003,7 +3003,7 @@ typedef struct
     CsrUint16                listenIntervalTu;
     CsrBool                  rxDtims;
     CsrWifiSmeD3AutoScanMode d3AutoScanMode;
-    CsrUint8                 clientTrafficWindow;
+    u8                 clientTrafficWindow;
     CsrBool                  opportunisticPowerSave;
     CsrBool                  noticeOfAbsence;
 } CsrWifiSmePowerConfig;
@@ -3041,7 +3041,7 @@ typedef struct
     CsrWifiSmeRoamingBandData roamingBands[3];
     CsrBool                   disableSmoothRoaming;
     CsrBool                   disableRoamScans;
-    CsrUint8                  reconnectLimit;
+    u8                  reconnectLimit;
     CsrUint16                 reconnectLimitIntervalMs;
     CsrWifiSmeScanConfigData  roamScanCfg[3];
 } CsrWifiSmeRoamingConfig;
@@ -3094,7 +3094,7 @@ typedef struct
     CsrInt8                  lowSnrThreshold;
     CsrInt8                  deltaSnrThreshold;
     CsrUint16                passiveChannelListCount;
-    CsrUint8                *passiveChannelList;
+    u8                *passiveChannelList;
 } CsrWifiSmeScanConfig;
 
 /*******************************************************************************
@@ -3149,11 +3149,11 @@ typedef struct
     CsrWifiSmeTsfTime        localTime;
     CsrUint16                channelFrequency;
     CsrUint16                capabilityInformation;
-    CsrUint8                 channelNumber;
+    u8                 channelNumber;
     CsrWifiSmeBasicUsability usability;
     CsrWifiSmeBssType        bssType;
     CsrUint16                informationElementsLength;
-    CsrUint8                *informationElements;
+    u8                *informationElements;
     CsrWifiSmeP2pRole        p2pDeviceRole;
     union {
         CsrWifiSmeEmpty        reservedCli;
@@ -3189,8 +3189,8 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8              connectionQualityRssiChangeTrigger;
-    CsrUint8              connectionQualitySnrChangeTrigger;
+    u8              connectionQualityRssiChangeTrigger;
+    u8              connectionQualitySnrChangeTrigger;
     CsrWifiSmeWmmModeMask wmmModeMask;
     CsrWifiSmeRadioIF     ifIndex;
     CsrBool               allowUnicastUseGroupCipher;
@@ -3221,11 +3221,11 @@ typedef struct
 typedef struct
 {
     CsrWifiSmeWepAuthMode wepAuthType;
-    CsrUint8              selectedWepKey;
-    CsrUint8              key1[13];
-    CsrUint8              key2[13];
-    CsrUint8              key3[13];
-    CsrUint8              key4[13];
+    u8              selectedWepKey;
+    u8              key1[13];
+    u8              key2[13];
+    u8              key3[13];
+    u8              key4[13];
 } CsrWifiSmeWep128Keys;
 
 /*******************************************************************************
@@ -3252,11 +3252,11 @@ typedef struct
 typedef struct
 {
     CsrWifiSmeWepAuthMode wepAuthType;
-    CsrUint8              selectedWepKey;
-    CsrUint8              key1[5];
-    CsrUint8              key2[5];
-    CsrUint8              key3[5];
-    CsrUint8              key4[5];
+    u8              selectedWepKey;
+    u8              key1[5];
+    u8              key2[5];
+    u8              key3[5];
+    u8              key4[5];
 } CsrWifiSmeWep64Keys;
 
 /*******************************************************************************
@@ -3315,23 +3315,23 @@ typedef struct
 *******************************************************************************/
 typedef struct
 {
-    CsrUint8                    wpsVersion;
-    CsrUint8                    uuid[16];
-    CsrUint8                    deviceName[32];
-    CsrUint8                    deviceNameLength;
-    CsrUint8                    manufacturer[64];
-    CsrUint8                    manufacturerLength;
-    CsrUint8                    modelName[32];
-    CsrUint8                    modelNameLength;
-    CsrUint8                    modelNumber[32];
-    CsrUint8                    modelNumberLength;
-    CsrUint8                    serialNumber[32];
+    u8                    wpsVersion;
+    u8                    uuid[16];
+    u8                    deviceName[32];
+    u8                    deviceNameLength;
+    u8                    manufacturer[64];
+    u8                    manufacturerLength;
+    u8                    modelName[32];
+    u8                    modelNameLength;
+    u8                    modelNumber[32];
+    u8                    modelNumberLength;
+    u8                    serialNumber[32];
     CsrWifiSmeWpsDeviceType     primDeviceType;
-    CsrUint8                    secondaryDeviceTypeCount;
+    u8                    secondaryDeviceTypeCount;
     CsrWifiSmeWpsDeviceType    *secondaryDeviceType;
     CsrWifiSmeWpsConfigTypeMask configMethods;
-    CsrUint8                    rfBands;
-    CsrUint8                    osVersion[4];
+    u8                    rfBands;
+    u8                    osVersion[4];
 } CsrWifiSmeWpsConfig;
 
 
@@ -3564,7 +3564,7 @@ typedef struct
     CsrWifiFsmEvent      common;
     CsrUint16            interfaceTag;
     CsrWifiSmeListAction action;
-    CsrUint8             setAddressCount;
+    u8             setAddressCount;
     CsrWifiMacAddress   *setAddresses;
 } CsrWifiSmeBlacklistReq;
 
@@ -3607,7 +3607,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       calibrationDataLength;
-    CsrUint8       *calibrationData;
+    u8       *calibrationData;
 } CsrWifiSmeCalibrationDataSetReq;
 
 /*******************************************************************************
@@ -4024,7 +4024,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       mibAttributeLength;
-    CsrUint8       *mibAttribute;
+    u8       *mibAttribute;
 } CsrWifiSmeMibGetNextReq;
 
 /*******************************************************************************
@@ -4047,7 +4047,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       mibAttributeLength;
-    CsrUint8       *mibAttribute;
+    u8       *mibAttribute;
 } CsrWifiSmeMibGetReq;
 
 /*******************************************************************************
@@ -4078,7 +4078,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint16       mibAttributeLength;
-    CsrUint8       *mibAttribute;
+    u8       *mibAttribute;
 } CsrWifiSmeMibSetReq;
 
 /*******************************************************************************
@@ -4109,7 +4109,7 @@ typedef struct
     CsrWifiFsmEvent      common;
     CsrUint16            interfaceTag;
     CsrWifiSmeListAction action;
-    CsrUint8             setAddressesCount;
+    u8             setAddressesCount;
     CsrWifiMacAddress   *setAddresses;
 } CsrWifiSmeMulticastAddressReq;
 
@@ -4159,7 +4159,7 @@ typedef struct
     CsrWifiFsmEvent            common;
     CsrUint16                  interfaceTag;
     CsrUint16                  filterLength;
-    CsrUint8                  *filter;
+    u8                  *filter;
     CsrWifiSmePacketFilterMode mode;
     CsrWifiIp4Address          arpFilterAddress;
 } CsrWifiSmePacketFilterSetReq;
@@ -4211,7 +4211,7 @@ typedef struct
     CsrWifiFsmEvent      common;
     CsrUint16            interfaceTag;
     CsrWifiSmeListAction action;
-    CsrUint8             setPmkidsCount;
+    u8             setPmkidsCount;
     CsrWifiSmePmkid     *setPmkids;
 } CsrWifiSmePmkidReq;
 
@@ -4398,16 +4398,16 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent    common;
-    CsrUint8           ssidCount;
+    u8           ssidCount;
     CsrWifiSsid       *ssid;
     CsrWifiMacAddress  bssid;
     CsrBool            forceScan;
     CsrWifiSmeBssType  bssType;
     CsrWifiSmeScanType scanType;
     CsrUint16          channelListCount;
-    CsrUint8          *channelList;
+    u8          *channelList;
     CsrUint16          probeIeLength;
-    CsrUint8          *probeIe;
+    u8          *probeIe;
 } CsrWifiSmeScanFullReq;
 
 /*******************************************************************************
@@ -4564,9 +4564,9 @@ typedef struct
     CsrBool                 strict;
     CsrWifiSmeTspecCtrlMask ctrlMask;
     CsrUint16               tspecLength;
-    CsrUint8               *tspec;
+    u8               *tspec;
     CsrUint16               tclasLength;
-    CsrUint8               *tclas;
+    u8               *tclas;
 } CsrWifiSmeTspecReq;
 
 /*******************************************************************************
@@ -4831,7 +4831,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint32       dataLength;
-    CsrUint8       *data;
+    u8       *data;
 } CsrWifiSmeSetReq;
 
 /*******************************************************************************
@@ -4980,7 +4980,7 @@ typedef struct
     CsrUint16            interfaceTag;
     CsrResult            status;
     CsrWifiSmeListAction action;
-    CsrUint8             getAddressCount;
+    u8             getAddressCount;
     CsrWifiMacAddress   *getAddresses;
 } CsrWifiSmeBlacklistCfm;
 
@@ -5006,7 +5006,7 @@ typedef struct
     CsrWifiFsmEvent common;
     CsrResult       status;
     CsrUint16       calibrationDataLength;
-    CsrUint8       *calibrationData;
+    u8       *calibrationData;
 } CsrWifiSmeCalibrationDataGetCfm;
 
 /*******************************************************************************
@@ -5535,7 +5535,7 @@ typedef struct
     CsrWifiFsmEvent common;
     CsrResult       status;
     CsrUint16       mibAttributeLength;
-    CsrUint8       *mibAttribute;
+    u8       *mibAttribute;
 } CsrWifiSmeMibGetCfm;
 
 /*******************************************************************************
@@ -5562,7 +5562,7 @@ typedef struct
     CsrWifiFsmEvent common;
     CsrResult       status;
     CsrUint16       mibAttributeLength;
-    CsrUint8       *mibAttribute;
+    u8       *mibAttribute;
 } CsrWifiSmeMibGetNextCfm;
 
 /*******************************************************************************
@@ -5641,7 +5641,7 @@ typedef struct
     CsrUint16            interfaceTag;
     CsrResult            status;
     CsrWifiSmeListAction action;
-    CsrUint8             getAddressesCount;
+    u8             getAddressesCount;
     CsrWifiMacAddress   *getAddresses;
 } CsrWifiSmeMulticastAddressCfm;
 
@@ -5709,7 +5709,7 @@ typedef struct
 {
     CsrWifiFsmEvent           common;
     CsrUint16                 interfaceTag;
-    CsrUint8                  pmkidCandidatesCount;
+    u8                  pmkidCandidatesCount;
     CsrWifiSmePmkidCandidate *pmkidCandidates;
 } CsrWifiSmePmkidCandidateListInd;
 
@@ -5740,7 +5740,7 @@ typedef struct
     CsrUint16            interfaceTag;
     CsrResult            status;
     CsrWifiSmeListAction action;
-    CsrUint8             getPmkidsCount;
+    u8             getPmkidsCount;
     CsrWifiSmePmkid     *getPmkids;
 } CsrWifiSmePmkidCfm;
 
@@ -6132,7 +6132,7 @@ typedef struct
     CsrUint32                 transactionId;
     CsrWifiSmeTspecResultCode tspecResultCode;
     CsrUint16                 tspecLength;
-    CsrUint8                 *tspec;
+    u8                 *tspec;
 } CsrWifiSmeTspecInd;
 
 /*******************************************************************************
@@ -6163,7 +6163,7 @@ typedef struct
     CsrUint32                 transactionId;
     CsrWifiSmeTspecResultCode tspecResultCode;
     CsrUint16                 tspecLength;
-    CsrUint8                 *tspec;
+    u8                 *tspec;
 } CsrWifiSmeTspecCfm;
 
 /*******************************************************************************
@@ -6400,7 +6400,7 @@ typedef struct
     CsrWifiFsmEvent common;
     CsrResult       status;
     CsrUint16       numInterfaces;
-    CsrUint8        capBitmap[2];
+    u8        capBitmap[2];
 } CsrWifiSmeInterfaceCapabilityGetCfm;
 
 /*******************************************************************************
@@ -6466,7 +6466,7 @@ typedef struct
 {
     CsrWifiFsmEvent common;
     CsrUint32       dataLength;
-    CsrUint8       *data;
+    u8       *data;
 } CsrWifiSmeCoreDumpInd;
 
 /*******************************************************************************
diff --git a/drivers/staging/csr/csr_wifi_sme_serialize.c b/drivers/staging/csr/csr_wifi_sme_serialize.c
index 5c1bc31f2dd..4558629f8bd 100644
--- a/drivers/staging/csr/csr_wifi_sme_serialize.c
+++ b/drivers/staging/csr/csr_wifi_sme_serialize.c
@@ -37,7 +37,7 @@ CsrSize CsrWifiSmeAdhocConfigSetReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeAdhocConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeAdhocConfigSetReq *primitive = (CsrWifiSmeAdhocConfigSetReq *)msg;
     *len = 0;
@@ -50,7 +50,7 @@ CsrUint8* CsrWifiSmeAdhocConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeAdhocConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeAdhocConfigSetReq *primitive = (CsrWifiSmeAdhocConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigSetReq));
     CsrSize offset;
@@ -74,26 +74,26 @@ CsrSize CsrWifiSmeBlacklistReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
-    bufferSize += 1; /* CsrUint8 primitive->setAddressCount */
+    bufferSize += 1; /* u8 primitive->setAddressCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->setAddressCount; i1++)
         {
-            bufferSize += 6; /* CsrUint8 primitive->setAddresses[i1].a[6] */
+            bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeBlacklistReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->setAddressCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->setAddressCount);
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->setAddressCount; i1++)
@@ -105,7 +105,7 @@ CsrUint8* CsrWifiSmeBlacklistReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeBlacklistReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeBlacklistReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *) CsrPmemAlloc(sizeof(CsrWifiSmeBlacklistReq));
     CsrSize offset;
@@ -113,8 +113,8 @@ void* CsrWifiSmeBlacklistReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->setAddressCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->setAddressCount, buffer, &offset);
     primitive->setAddresses = NULL;
     if (primitive->setAddressCount)
     {
@@ -147,12 +147,12 @@ CsrSize CsrWifiSmeCalibrationDataSetReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
     bufferSize += 2;                                /* CsrUint16 primitive->calibrationDataLength */
-    bufferSize += primitive->calibrationDataLength; /* CsrUint8 primitive->calibrationData */
+    bufferSize += primitive->calibrationDataLength; /* u8 primitive->calibrationData */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeCalibrationDataSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *)msg;
     *len = 0;
@@ -166,7 +166,7 @@ CsrUint8* CsrWifiSmeCalibrationDataSetReqSer(CsrUint8 *ptr, CsrSize *len, void *
 }
 
 
-void* CsrWifiSmeCalibrationDataSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataSetReq));
     CsrSize offset;
@@ -176,7 +176,7 @@ void* CsrWifiSmeCalibrationDataSetReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->calibrationDataLength, buffer, &offset);
     if (primitive->calibrationDataLength)
     {
-        primitive->calibrationData = (CsrUint8 *)CsrPmemAlloc(primitive->calibrationDataLength);
+        primitive->calibrationData = (u8 *)CsrPmemAlloc(primitive->calibrationDataLength);
         CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((CsrUint16) (primitive->calibrationDataLength)));
     }
     else
@@ -202,29 +202,29 @@ CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 1; /* CsrUint8 primitive->ccxConfig.keepAliveTimeMs */
+    bufferSize += 1; /* u8 primitive->ccxConfig.keepAliveTimeMs */
     bufferSize += 1; /* CsrBool primitive->ccxConfig.apRoamingEnabled */
-    bufferSize += 1; /* CsrUint8 primitive->ccxConfig.measurementsMask */
+    bufferSize += 1; /* u8 primitive->ccxConfig.measurementsMask */
     bufferSize += 1; /* CsrBool primitive->ccxConfig.ccxRadioMgtEnabled */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeCcxConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCcxConfigSetReq *primitive = (CsrWifiSmeCcxConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.keepAliveTimeMs);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.apRoamingEnabled);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.measurementsMask);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.ccxRadioMgtEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.keepAliveTimeMs);
+    CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.apRoamingEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.measurementsMask);
+    CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.ccxRadioMgtEnabled);
     return(ptr);
 }
 
 
-void* CsrWifiSmeCcxConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCcxConfigSetReq *primitive = (CsrWifiSmeCcxConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigSetReq));
     CsrSize offset;
@@ -232,10 +232,10 @@ void* CsrWifiSmeCcxConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.ccxRadioMgtEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ccxConfig.ccxRadioMgtEnabled, buffer, &offset);
 
     return primitive;
 }
@@ -264,13 +264,13 @@ CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeCoexConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCoexConfigSetReq *primitive = (CsrWifiSmeCoexConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexEnableSchemeManagement);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexPeriodicWakeHost);
+    CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexEnableSchemeManagement);
+    CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexPeriodicWakeHost);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutDurationMs);
@@ -287,15 +287,15 @@ CsrUint8* CsrWifiSmeCoexConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCoexConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCoexConfigSetReq *primitive = (CsrWifiSmeCoexConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigSetReq));
     CsrSize offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexPeriodicWakeHost, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->coexConfig.coexPeriodicWakeHost, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
@@ -320,35 +320,35 @@ CsrSize CsrWifiSmeConnectReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 57) */
     bufferSize += 2;                                                                     /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 32;                                                                    /* CsrUint8 primitive->connectionConfig.ssid.ssid[32] */
-    bufferSize += 1;                                                                     /* CsrUint8 primitive->connectionConfig.ssid.length */
-    bufferSize += 6;                                                                     /* CsrUint8 primitive->connectionConfig.bssid.a[6] */
+    bufferSize += 32;                                                                    /* u8 primitive->connectionConfig.ssid.ssid[32] */
+    bufferSize += 1;                                                                     /* u8 primitive->connectionConfig.ssid.length */
+    bufferSize += 6;                                                                     /* u8 primitive->connectionConfig.bssid.a[6] */
     bufferSize += 1;                                                                     /* CsrWifiSmeBssType primitive->connectionConfig.bssType */
     bufferSize += 1;                                                                     /* CsrWifiSmeRadioIF primitive->connectionConfig.ifIndex */
     bufferSize += 1;                                                                     /* CsrWifiSme80211PrivacyMode primitive->connectionConfig.privacyMode */
     bufferSize += 2;                                                                     /* CsrWifiSmeAuthModeMask primitive->connectionConfig.authModeMask */
     bufferSize += 2;                                                                     /* CsrWifiSmeEncryptionMask primitive->connectionConfig.encryptionModeMask */
     bufferSize += 2;                                                                     /* CsrUint16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
-    bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* CsrUint8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
+    bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* u8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
     bufferSize += 1;                                                                     /* CsrWifiSmeWmmQosInfoMask primitive->connectionConfig.wmmQosInfo */
     bufferSize += 1;                                                                     /* CsrBool primitive->connectionConfig.adhocJoinOnly */
-    bufferSize += 1;                                                                     /* CsrUint8 primitive->connectionConfig.adhocChannel */
+    bufferSize += 1;                                                                     /* u8 primitive->connectionConfig.adhocChannel */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeConnectReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ssid.length);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ssid.length);
     CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.bssType);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ifIndex);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.privacyMode);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.bssType);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ifIndex);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.privacyMode);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.authModeMask);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.encryptionModeMask);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
@@ -356,14 +356,14 @@ CsrUint8* CsrWifiSmeConnectReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
     {
         CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.wmmQosInfo);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocJoinOnly);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocChannel);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.wmmQosInfo);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocJoinOnly);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocChannel);
     return(ptr);
 }
 
 
-void* CsrWifiSmeConnectReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectReq));
     CsrSize offset;
@@ -372,26 +372,26 @@ void* CsrWifiSmeConnectReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
     CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.bssType, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.bssType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
     if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
     {
-        primitive->connectionConfig.mlmeAssociateReqInformationElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+        primitive->connectionConfig.mlmeAssociateReqInformationElements = (u8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
         CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
     }
     else
     {
         primitive->connectionConfig.mlmeAssociateReqInformationElements = NULL;
     }
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.wmmQosInfo, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocJoinOnly, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocChannel, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.wmmQosInfo, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.adhocJoinOnly, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.adhocChannel, buffer, &offset);
 
     return primitive;
 }
@@ -417,19 +417,19 @@ CsrSize CsrWifiSmeHostConfigSetReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeHostConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeHostConfigSetReq *primitive = (CsrWifiSmeHostConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->hostConfig.powerMode);
+    CsrUint8Ser(ptr, len, (u8) primitive->hostConfig.powerMode);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->hostConfig.applicationDataPeriodMs);
     return(ptr);
 }
 
 
-void* CsrWifiSmeHostConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeHostConfigSetReq *primitive = (CsrWifiSmeHostConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigSetReq));
     CsrSize offset;
@@ -437,7 +437,7 @@ void* CsrWifiSmeHostConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->hostConfig.powerMode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->hostConfig.powerMode, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
 
     return primitive;
@@ -452,7 +452,7 @@ CsrSize CsrWifiSmeKeyReqSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
     bufferSize += 1; /* CsrWifiSmeKeyType primitive->key.keyType */
-    bufferSize += 1; /* CsrUint8 primitive->key.keyIndex */
+    bufferSize += 1; /* u8 primitive->key.keyIndex */
     bufferSize += 1; /* CsrBool primitive->key.wepTxKey */
     {
         CsrUint16 i2;
@@ -462,23 +462,23 @@ CsrSize CsrWifiSmeKeyReqSizeof(void *msg)
         }
     }
     bufferSize += 1;         /* CsrBool primitive->key.authenticator */
-    bufferSize += 6;         /* CsrUint8 primitive->key.address.a[6] */
-    bufferSize += 1;         /* CsrUint8 primitive->key.keyLength */
-    bufferSize += 32;        /* CsrUint8 primitive->key.key[32] */
+    bufferSize += 6;         /* u8 primitive->key.address.a[6] */
+    bufferSize += 1;         /* u8 primitive->key.keyLength */
+    bufferSize += 32;        /* u8 primitive->key.key[32] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeKeyReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeKeyReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeKeyReq *primitive = (CsrWifiSmeKeyReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.keyType);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.keyIndex);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.wepTxKey);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->key.keyType);
+    CsrUint8Ser(ptr, len, (u8) primitive->key.keyIndex);
+    CsrUint8Ser(ptr, len, (u8) primitive->key.wepTxKey);
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < 8; i2++)
@@ -486,15 +486,15 @@ CsrUint8* CsrWifiSmeKeyReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->key.keyRsc[i2]);
         }
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.authenticator);
+    CsrUint8Ser(ptr, len, (u8) primitive->key.authenticator);
     CsrMemCpySer(ptr, len, (const void *) primitive->key.address.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.keyLength);
+    CsrUint8Ser(ptr, len, (u8) primitive->key.keyLength);
     CsrMemCpySer(ptr, len, (const void *) primitive->key.key, ((CsrUint16) (32)));
     return(ptr);
 }
 
 
-void* CsrWifiSmeKeyReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeKeyReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeKeyReq *primitive = (CsrWifiSmeKeyReq *) CsrPmemAlloc(sizeof(CsrWifiSmeKeyReq));
     CsrSize offset;
@@ -502,10 +502,10 @@ void* CsrWifiSmeKeyReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->key.keyType, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->key.keyIndex, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->key.wepTxKey, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->key.keyType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->key.keyIndex, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->key.wepTxKey, buffer, &offset);
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < 8; i2++)
@@ -513,9 +513,9 @@ void* CsrWifiSmeKeyReqDes(CsrUint8 *buffer, CsrSize length)
             CsrUint16Des((CsrUint16 *) &primitive->key.keyRsc[i2], buffer, &offset);
         }
     }
-    CsrUint8Des((CsrUint8 *) &primitive->key.authenticator, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->key.authenticator, buffer, &offset);
     CsrMemCpyDes(primitive->key.address.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->key.keyLength, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->key.keyLength, buffer, &offset);
     CsrMemCpyDes(primitive->key.key, buffer, &offset, ((CsrUint16) (32)));
 
     return primitive;
@@ -528,7 +528,7 @@ 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; /* CsrUint8 primitive->mibConfig.unifiFixTxDataRate */
+    bufferSize += 1; /* u8 primitive->mibConfig.unifiFixTxDataRate */
     bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11RtsThreshold */
     bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11FragmentationThreshold */
     bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11CurrentTxPowerLevel */
@@ -536,13 +536,13 @@ CsrSize CsrWifiSmeMibConfigSetReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeMibConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMibConfigSetReq *primitive = (CsrWifiSmeMibConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixMaxTxDataRate);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixTxDataRate);
+    CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixMaxTxDataRate);
+    CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixTxDataRate);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11RtsThreshold);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11FragmentationThreshold);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11CurrentTxPowerLevel);
@@ -550,15 +550,15 @@ CsrUint8* CsrWifiSmeMibConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMibConfigSetReq *primitive = (CsrWifiSmeMibConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigSetReq));
     CsrSize offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixTxDataRate, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixTxDataRate, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
@@ -574,12 +574,12 @@ CsrSize CsrWifiSmeMibGetNextReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
     bufferSize += 2;                             /* CsrUint16 primitive->mibAttributeLength */
-    bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+    bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeMibGetNextReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *)msg;
     *len = 0;
@@ -593,7 +593,7 @@ CsrUint8* CsrWifiSmeMibGetNextReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibGetNextReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetNextReq));
     CsrSize offset;
@@ -603,7 +603,7 @@ void* CsrWifiSmeMibGetNextReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
     if (primitive->mibAttributeLength)
     {
-        primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+        primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
         CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
     }
     else
@@ -630,12 +630,12 @@ CsrSize CsrWifiSmeMibGetReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
     bufferSize += 2;                             /* CsrUint16 primitive->mibAttributeLength */
-    bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+    bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeMibGetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *)msg;
     *len = 0;
@@ -649,7 +649,7 @@ CsrUint8* CsrWifiSmeMibGetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibGetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetReq));
     CsrSize offset;
@@ -659,7 +659,7 @@ void* CsrWifiSmeMibGetReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
     if (primitive->mibAttributeLength)
     {
-        primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+        primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
         CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
     }
     else
@@ -686,12 +686,12 @@ CsrSize CsrWifiSmeMibSetReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
     bufferSize += 2;                             /* CsrUint16 primitive->mibAttributeLength */
-    bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+    bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeMibSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *)msg;
     *len = 0;
@@ -705,7 +705,7 @@ CsrUint8* CsrWifiSmeMibSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibSetReq));
     CsrSize offset;
@@ -715,7 +715,7 @@ void* CsrWifiSmeMibSetReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
     if (primitive->mibAttributeLength)
     {
-        primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+        primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
         CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
     }
     else
@@ -743,26 +743,26 @@ CsrSize CsrWifiSmeMulticastAddressReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
-    bufferSize += 1; /* CsrUint8 primitive->setAddressesCount */
+    bufferSize += 1; /* u8 primitive->setAddressesCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
         {
-            bufferSize += 6; /* CsrUint8 primitive->setAddresses[i1].a[6] */
+            bufferSize += 6; /* u8 primitive->setAddresses[i1].a[6] */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeMulticastAddressReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->setAddressesCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->setAddressesCount);
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
@@ -774,7 +774,7 @@ CsrUint8* CsrWifiSmeMulticastAddressReqSer(CsrUint8 *ptr, CsrSize *len, void *ms
 }
 
 
-void* CsrWifiSmeMulticastAddressReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMulticastAddressReq));
     CsrSize offset;
@@ -782,8 +782,8 @@ void* CsrWifiSmeMulticastAddressReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->setAddressesCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->setAddressesCount, buffer, &offset);
     primitive->setAddresses = NULL;
     if (primitive->setAddressesCount)
     {
@@ -817,14 +817,14 @@ CsrSize CsrWifiSmePacketFilterSetReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2;                       /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;                       /* CsrUint16 primitive->filterLength */
-    bufferSize += primitive->filterLength; /* CsrUint8 primitive->filter */
+    bufferSize += primitive->filterLength; /* u8 primitive->filter */
     bufferSize += 1;                       /* CsrWifiSmePacketFilterMode primitive->mode */
-    bufferSize += 4;                       /* CsrUint8 primitive->arpFilterAddress.a[4] */
+    bufferSize += 4;                       /* u8 primitive->arpFilterAddress.a[4] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmePacketFilterSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *)msg;
     *len = 0;
@@ -835,13 +835,13 @@ CsrUint8* CsrWifiSmePacketFilterSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg
     {
         CsrMemCpySer(ptr, len, (const void *) primitive->filter, ((CsrUint16) (primitive->filterLength)));
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->mode);
+    CsrUint8Ser(ptr, len, (u8) primitive->mode);
     CsrMemCpySer(ptr, len, (const void *) primitive->arpFilterAddress.a, ((CsrUint16) (4)));
     return(ptr);
 }
 
 
-void* CsrWifiSmePacketFilterSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePacketFilterSetReq));
     CsrSize offset;
@@ -852,14 +852,14 @@ void* CsrWifiSmePacketFilterSetReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->filterLength, buffer, &offset);
     if (primitive->filterLength)
     {
-        primitive->filter = (CsrUint8 *)CsrPmemAlloc(primitive->filterLength);
+        primitive->filter = (u8 *)CsrPmemAlloc(primitive->filterLength);
         CsrMemCpyDes(primitive->filter, buffer, &offset, ((CsrUint16) (primitive->filterLength)));
     }
     else
     {
         primitive->filter = NULL;
     }
-    CsrUint8Des((CsrUint8 *) &primitive->mode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->mode, buffer, &offset);
     CsrMemCpyDes(primitive->arpFilterAddress.a, buffer, &offset, ((CsrUint16) (4)));
 
     return primitive;
@@ -882,27 +882,27 @@ CsrSize CsrWifiSmePmkidReqSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 29) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
-    bufferSize += 1; /* CsrUint8 primitive->setPmkidsCount */
+    bufferSize += 1; /* u8 primitive->setPmkidsCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
         {
-            bufferSize += 6;  /* CsrUint8 primitive->setPmkids[i1].bssid.a[6] */
-            bufferSize += 16; /* CsrUint8 primitive->setPmkids[i1].pmkid[16] */
+            bufferSize += 6;  /* u8 primitive->setPmkids[i1].bssid.a[6] */
+            bufferSize += 16; /* u8 primitive->setPmkids[i1].pmkid[16] */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmePmkidReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePmkidReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->setPmkidsCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->setPmkidsCount);
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
@@ -915,7 +915,7 @@ CsrUint8* CsrWifiSmePmkidReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmePmkidReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePmkidReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidReq));
     CsrSize offset;
@@ -923,8 +923,8 @@ void* CsrWifiSmePmkidReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->setPmkidsCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->setPmkidsCount, buffer, &offset);
     primitive->setPmkids = NULL;
     if (primitive->setPmkidsCount)
     {
@@ -960,43 +960,43 @@ CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->powerConfig.listenIntervalTu */
     bufferSize += 1; /* CsrBool primitive->powerConfig.rxDtims */
     bufferSize += 1; /* CsrWifiSmeD3AutoScanMode primitive->powerConfig.d3AutoScanMode */
-    bufferSize += 1; /* CsrUint8 primitive->powerConfig.clientTrafficWindow */
+    bufferSize += 1; /* u8 primitive->powerConfig.clientTrafficWindow */
     bufferSize += 1; /* CsrBool primitive->powerConfig.opportunisticPowerSave */
     bufferSize += 1; /* CsrBool primitive->powerConfig.noticeOfAbsence */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmePowerConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmePowerConfigSetReq *primitive = (CsrWifiSmePowerConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.powerSaveLevel);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.powerSaveLevel);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->powerConfig.listenIntervalTu);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.rxDtims);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.d3AutoScanMode);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.clientTrafficWindow);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.opportunisticPowerSave);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.noticeOfAbsence);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.rxDtims);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.d3AutoScanMode);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.clientTrafficWindow);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.opportunisticPowerSave);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.noticeOfAbsence);
     return(ptr);
 }
 
 
-void* CsrWifiSmePowerConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmePowerConfigSetReq *primitive = (CsrWifiSmePowerConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigSetReq));
     CsrSize offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.opportunisticPowerSave, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.noticeOfAbsence, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.opportunisticPowerSave, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.noticeOfAbsence, buffer, &offset);
 
     return primitive;
 }
@@ -1020,7 +1020,7 @@ CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg)
     }
     bufferSize += 1;         /* CsrBool primitive->roamingConfig.disableSmoothRoaming */
     bufferSize += 1;         /* CsrBool primitive->roamingConfig.disableRoamScans */
-    bufferSize += 1;         /* CsrUint8 primitive->roamingConfig.reconnectLimit */
+    bufferSize += 1;         /* u8 primitive->roamingConfig.reconnectLimit */
     bufferSize += 2;         /* CsrUint16 primitive->roamingConfig.reconnectLimitIntervalMs */
     {
         CsrUint16 i2;
@@ -1038,7 +1038,7 @@ CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeRoamingConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeRoamingConfigSetReq *primitive = (CsrWifiSmeRoamingConfigSetReq *)msg;
     *len = 0;
@@ -1054,9 +1054,9 @@ CsrUint8* CsrWifiSmeRoamingConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *ms
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
         }
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableSmoothRoaming);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableRoamScans);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.reconnectLimit);
+    CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableSmoothRoaming);
+    CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableRoamScans);
+    CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.reconnectLimit);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.reconnectLimitIntervalMs);
     {
         CsrUint16 i2;
@@ -1074,7 +1074,7 @@ CsrUint8* CsrWifiSmeRoamingConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *ms
 }
 
 
-void* CsrWifiSmeRoamingConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeRoamingConfigSetReq *primitive = (CsrWifiSmeRoamingConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigSetReq));
     CsrSize offset;
@@ -1092,9 +1092,9 @@ void* CsrWifiSmeRoamingConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
             CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
         }
     }
-    CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.reconnectLimit, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->roamingConfig.reconnectLimit, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
     {
         CsrUint16 i2;
@@ -1140,12 +1140,12 @@ CsrSize CsrWifiSmeScanConfigSetReqSizeof(void *msg)
     bufferSize += 1;                                             /* CsrInt8 primitive->scanConfig.lowSnrThreshold */
     bufferSize += 1;                                             /* CsrInt8 primitive->scanConfig.deltaSnrThreshold */
     bufferSize += 2;                                             /* CsrUint16 primitive->scanConfig.passiveChannelListCount */
-    bufferSize += primitive->scanConfig.passiveChannelListCount; /* CsrUint8 primitive->scanConfig.passiveChannelList */
+    bufferSize += primitive->scanConfig.passiveChannelListCount; /* u8 primitive->scanConfig.passiveChannelList */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeScanConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *)msg;
     *len = 0;
@@ -1162,14 +1162,14 @@ CsrUint8* CsrWifiSmeScanConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
         }
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.disableAutonomousScans);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.disableAutonomousScans);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.maxResults);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highRssiThreshold);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowRssiThreshold);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaRssiThreshold);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highSnrThreshold);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowSnrThreshold);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaSnrThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highRssiThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowRssiThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaRssiThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highSnrThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowSnrThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaSnrThreshold);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.passiveChannelListCount);
     if (primitive->scanConfig.passiveChannelListCount)
     {
@@ -1179,7 +1179,7 @@ CsrUint8* CsrWifiSmeScanConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeScanConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigSetReq));
     CsrSize offset;
@@ -1198,18 +1198,18 @@ void* CsrWifiSmeScanConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
             CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
         }
     }
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->scanConfig.maxResults, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaSnrThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.deltaSnrThreshold, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
     if (primitive->scanConfig.passiveChannelListCount)
     {
-        primitive->scanConfig.passiveChannelList = (CsrUint8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
+        primitive->scanConfig.passiveChannelList = (u8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
         CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
     }
     else
@@ -1235,45 +1235,45 @@ CsrSize CsrWifiSmeScanFullReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 52) */
-    bufferSize += 1; /* CsrUint8 primitive->ssidCount */
+    bufferSize += 1; /* u8 primitive->ssidCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->ssidCount; i1++)
         {
-            bufferSize += 32;                  /* CsrUint8 primitive->ssid[i1].ssid[32] */
-            bufferSize += 1;                   /* CsrUint8 primitive->ssid[i1].length */
+            bufferSize += 32;                  /* u8 primitive->ssid[i1].ssid[32] */
+            bufferSize += 1;                   /* u8 primitive->ssid[i1].length */
         }
     }
-    bufferSize += 6;                           /* CsrUint8 primitive->bssid.a[6] */
+    bufferSize += 6;                           /* u8 primitive->bssid.a[6] */
     bufferSize += 1;                           /* CsrBool primitive->forceScan */
     bufferSize += 1;                           /* CsrWifiSmeBssType primitive->bssType */
     bufferSize += 1;                           /* CsrWifiSmeScanType primitive->scanType */
     bufferSize += 2;                           /* CsrUint16 primitive->channelListCount */
-    bufferSize += primitive->channelListCount; /* CsrUint8 primitive->channelList */
+    bufferSize += primitive->channelListCount; /* u8 primitive->channelList */
     bufferSize += 2;                           /* CsrUint16 primitive->probeIeLength */
-    bufferSize += primitive->probeIeLength;    /* CsrUint8 primitive->probeIe */
+    bufferSize += primitive->probeIeLength;    /* u8 primitive->probeIe */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeScanFullReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanFullReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssidCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->ssidCount);
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->ssidCount; i1++)
         {
             CsrMemCpySer(ptr, len, (const void *) primitive->ssid[i1].ssid, ((CsrUint16) (32)));
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid[i1].length);
+            CsrUint8Ser(ptr, len, (u8) primitive->ssid[i1].length);
         }
     }
     CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->forceScan);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->bssType);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanType);
+    CsrUint8Ser(ptr, len, (u8) primitive->forceScan);
+    CsrUint8Ser(ptr, len, (u8) primitive->bssType);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanType);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->channelListCount);
     if (primitive->channelListCount)
     {
@@ -1288,14 +1288,14 @@ CsrUint8* CsrWifiSmeScanFullReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeScanFullReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeScanFullReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanFullReq));
     CsrSize offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ssidCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ssidCount, buffer, &offset);
     primitive->ssid = NULL;
     if (primitive->ssidCount)
     {
@@ -1306,17 +1306,17 @@ void* CsrWifiSmeScanFullReqDes(CsrUint8 *buffer, CsrSize length)
         for (i1 = 0; i1 < primitive->ssidCount; i1++)
         {
             CsrMemCpyDes(primitive->ssid[i1].ssid, buffer, &offset, ((CsrUint16) (32)));
-            CsrUint8Des((CsrUint8 *) &primitive->ssid[i1].length, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->ssid[i1].length, buffer, &offset);
         }
     }
     CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->forceScan, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->bssType, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->forceScan, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->bssType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanType, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->channelListCount, buffer, &offset);
     if (primitive->channelListCount)
     {
-        primitive->channelList = (CsrUint8 *)CsrPmemAlloc(primitive->channelListCount);
+        primitive->channelList = (u8 *)CsrPmemAlloc(primitive->channelListCount);
         CsrMemCpyDes(primitive->channelList, buffer, &offset, ((CsrUint16) (primitive->channelListCount)));
     }
     else
@@ -1326,7 +1326,7 @@ void* CsrWifiSmeScanFullReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->probeIeLength, buffer, &offset);
     if (primitive->probeIeLength)
     {
-        primitive->probeIe = (CsrUint8 *)CsrPmemAlloc(primitive->probeIeLength);
+        primitive->probeIe = (u8 *)CsrPmemAlloc(primitive->probeIeLength);
         CsrMemCpyDes(primitive->probeIe, buffer, &offset, ((CsrUint16) (primitive->probeIeLength)));
     }
     else
@@ -1354,8 +1354,8 @@ CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
-    bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
+    bufferSize += 1; /* u8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
+    bufferSize += 1; /* u8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
     bufferSize += 1; /* CsrWifiSmeWmmModeMask primitive->smeConfig.wmmModeMask */
     bufferSize += 1; /* CsrWifiSmeRadioIF primitive->smeConfig.ifIndex */
     bufferSize += 1; /* CsrBool primitive->smeConfig.allowUnicastUseGroupCipher */
@@ -1364,23 +1364,23 @@ CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeSmeStaConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeSmeStaConfigSetReq *primitive = (CsrWifiSmeSmeStaConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.wmmModeMask);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.ifIndex);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.allowUnicastUseGroupCipher);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.enableOpportunisticKeyCaching);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.wmmModeMask);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.ifIndex);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.allowUnicastUseGroupCipher);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.enableOpportunisticKeyCaching);
     return(ptr);
 }
 
 
-void* CsrWifiSmeSmeStaConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeSmeStaConfigSetReq *primitive = (CsrWifiSmeSmeStaConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigSetReq));
     CsrSize offset;
@@ -1388,12 +1388,12 @@ void* CsrWifiSmeSmeStaConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.ifIndex, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.allowUnicastUseGroupCipher, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.enableOpportunisticKeyCaching, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.ifIndex, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.allowUnicastUseGroupCipher, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.enableOpportunisticKeyCaching, buffer, &offset);
 
     return primitive;
 }
@@ -1411,23 +1411,23 @@ CsrSize CsrWifiSmeTspecReqSizeof(void *msg)
     bufferSize += 1;                      /* CsrBool primitive->strict */
     bufferSize += 1;                      /* CsrWifiSmeTspecCtrlMask primitive->ctrlMask */
     bufferSize += 2;                      /* CsrUint16 primitive->tspecLength */
-    bufferSize += primitive->tspecLength; /* CsrUint8 primitive->tspec */
+    bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
     bufferSize += 2;                      /* CsrUint16 primitive->tclasLength */
-    bufferSize += primitive->tclasLength; /* CsrUint8 primitive->tclas */
+    bufferSize += primitive->tclasLength; /* u8 primitive->tclas */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeTspecReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeTspecReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->strict);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ctrlMask);
+    CsrUint8Ser(ptr, len, (u8) primitive->strict);
+    CsrUint8Ser(ptr, len, (u8) primitive->ctrlMask);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
     if (primitive->tspecLength)
     {
@@ -1442,7 +1442,7 @@ CsrUint8* CsrWifiSmeTspecReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeTspecReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeTspecReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecReq));
     CsrSize offset;
@@ -1450,14 +1450,14 @@ void* CsrWifiSmeTspecReqDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->strict, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ctrlMask, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->strict, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ctrlMask, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
     if (primitive->tspecLength)
     {
-        primitive->tspec = (CsrUint8 *)CsrPmemAlloc(primitive->tspecLength);
+        primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
         CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
     }
     else
@@ -1467,7 +1467,7 @@ void* CsrWifiSmeTspecReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
     if (primitive->tclasLength)
     {
-        primitive->tclas = (CsrUint8 *)CsrPmemAlloc(primitive->tclasLength);
+        primitive->tclas = (u8 *)CsrPmemAlloc(primitive->tclasLength);
         CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
     }
     else
@@ -1494,21 +1494,21 @@ CsrSize CsrWifiSmeWifiFlightmodeReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
-    bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+    bufferSize += 6; /* u8 primitive->address.a[6] */
     bufferSize += 2; /* CsrUint16 primitive->mibFilesCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
         {
             bufferSize += 2;                              /* CsrUint16 primitive->mibFiles[i1].length */
-            bufferSize += primitive->mibFiles[i1].length; /* CsrUint8 primitive->mibFiles[i1].data */
+            bufferSize += primitive->mibFiles[i1].length; /* u8 primitive->mibFiles[i1].data */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeWifiFlightmodeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *)msg;
     *len = 0;
@@ -1530,7 +1530,7 @@ CsrUint8* CsrWifiSmeWifiFlightmodeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeWifiFlightmodeReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiFlightmodeReq));
     CsrSize offset;
@@ -1551,7 +1551,7 @@ void* CsrWifiSmeWifiFlightmodeReqDes(CsrUint8 *buffer, CsrSize length)
             CsrUint16Des((CsrUint16 *) &primitive->mibFiles[i1].length, buffer, &offset);
             if (primitive->mibFiles[i1].length)
             {
-                primitive->mibFiles[i1].data = (CsrUint8 *)CsrPmemAlloc(primitive->mibFiles[i1].length);
+                primitive->mibFiles[i1].data = (u8 *)CsrPmemAlloc(primitive->mibFiles[i1].length);
                 CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((CsrUint16) (primitive->mibFiles[i1].length)));
             }
             else
@@ -1586,21 +1586,21 @@ CsrSize CsrWifiSmeWifiOnReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
-    bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+    bufferSize += 6; /* u8 primitive->address.a[6] */
     bufferSize += 2; /* CsrUint16 primitive->mibFilesCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
         {
             bufferSize += 2;                              /* CsrUint16 primitive->mibFiles[i1].length */
-            bufferSize += primitive->mibFiles[i1].length; /* CsrUint8 primitive->mibFiles[i1].data */
+            bufferSize += primitive->mibFiles[i1].length; /* u8 primitive->mibFiles[i1].data */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *)msg;
     *len = 0;
@@ -1622,7 +1622,7 @@ CsrUint8* CsrWifiSmeWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeWifiOnReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeWifiOnReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnReq));
     CsrSize offset;
@@ -1643,7 +1643,7 @@ void* CsrWifiSmeWifiOnReqDes(CsrUint8 *buffer, CsrSize length)
             CsrUint16Des((CsrUint16 *) &primitive->mibFiles[i1].length, buffer, &offset);
             if (primitive->mibFiles[i1].length)
             {
-                primitive->mibFiles[i1].data = (CsrUint8 *)CsrPmemAlloc(primitive->mibFiles[i1].length);
+                primitive->mibFiles[i1].data = (u8 *)CsrPmemAlloc(primitive->mibFiles[i1].length);
                 CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((CsrUint16) (primitive->mibFiles[i1].length)));
             }
             else
@@ -1678,45 +1678,45 @@ CsrSize CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 37) */
-    bufferSize += 1; /* CsrUint8 primitive->cloakedSsids.cloakedSsidsCount */
+    bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsidsCount */
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
-            bufferSize += 32; /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
-            bufferSize += 1;  /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].length */
+            bufferSize += 32; /* u8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
+            bufferSize += 1;  /* u8 primitive->cloakedSsids.cloakedSsids[i2].length */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeCloakedSsidsSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsidsCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsidsCount);
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
             CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((CsrUint16) (32)));
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsids[i2].length);
+            CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsids[i2].length);
         }
     }
     return(ptr);
 }
 
 
-void* CsrWifiSmeCloakedSsidsSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsSetReq));
     CsrSize offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
     primitive->cloakedSsids.cloakedSsids = NULL;
     if (primitive->cloakedSsids.cloakedSsidsCount)
     {
@@ -1727,7 +1727,7 @@ void* CsrWifiSmeCloakedSsidsSetReqDes(CsrUint8 *buffer, CsrSize length)
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
             CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((CsrUint16) (32)));
-            CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
         }
     }
 
@@ -1749,37 +1749,37 @@ CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 1; /* CsrWifiSme80211dTrustLevel primitive->deviceConfig.trustLevel */
-    bufferSize += 2; /* CsrUint8 primitive->deviceConfig.countryCode[2] */
+    bufferSize += 2; /* u8 primitive->deviceConfig.countryCode[2] */
     bufferSize += 1; /* CsrWifiSmeFirmwareDriverInterface primitive->deviceConfig.firmwareDriverInterface */
     bufferSize += 1; /* CsrBool primitive->deviceConfig.enableStrictDraftN */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeSmeCommonConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeSmeCommonConfigSetReq *primitive = (CsrWifiSmeSmeCommonConfigSetReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.trustLevel);
+    CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.trustLevel);
     CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((CsrUint16) (2)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.firmwareDriverInterface);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.enableStrictDraftN);
+    CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.firmwareDriverInterface);
+    CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.enableStrictDraftN);
     return(ptr);
 }
 
 
-void* CsrWifiSmeSmeCommonConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeSmeCommonConfigSetReq *primitive = (CsrWifiSmeSmeCommonConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigSetReq));
     CsrSize offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
     CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((CsrUint16) (2)));
-    CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
 
     return primitive;
 }
@@ -1791,51 +1791,51 @@ CsrSize CsrWifiSmeWpsConfigurationReqSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 240) */
-    bufferSize += 1;  /* CsrUint8 primitive->wpsConfig.wpsVersion */
-    bufferSize += 16; /* CsrUint8 primitive->wpsConfig.uuid[16] */
-    bufferSize += 32; /* CsrUint8 primitive->wpsConfig.deviceName[32] */
-    bufferSize += 1;  /* CsrUint8 primitive->wpsConfig.deviceNameLength */
-    bufferSize += 64; /* CsrUint8 primitive->wpsConfig.manufacturer[64] */
-    bufferSize += 1;  /* CsrUint8 primitive->wpsConfig.manufacturerLength */
-    bufferSize += 32; /* CsrUint8 primitive->wpsConfig.modelName[32] */
-    bufferSize += 1;  /* CsrUint8 primitive->wpsConfig.modelNameLength */
-    bufferSize += 32; /* CsrUint8 primitive->wpsConfig.modelNumber[32] */
-    bufferSize += 1;  /* CsrUint8 primitive->wpsConfig.modelNumberLength */
-    bufferSize += 32; /* CsrUint8 primitive->wpsConfig.serialNumber[32] */
-    bufferSize += 8;  /* CsrUint8 primitive->wpsConfig.primDeviceType.deviceDetails[8] */
-    bufferSize += 1;  /* CsrUint8 primitive->wpsConfig.secondaryDeviceTypeCount */
+    bufferSize += 1;  /* u8 primitive->wpsConfig.wpsVersion */
+    bufferSize += 16; /* u8 primitive->wpsConfig.uuid[16] */
+    bufferSize += 32; /* u8 primitive->wpsConfig.deviceName[32] */
+    bufferSize += 1;  /* u8 primitive->wpsConfig.deviceNameLength */
+    bufferSize += 64; /* u8 primitive->wpsConfig.manufacturer[64] */
+    bufferSize += 1;  /* u8 primitive->wpsConfig.manufacturerLength */
+    bufferSize += 32; /* u8 primitive->wpsConfig.modelName[32] */
+    bufferSize += 1;  /* u8 primitive->wpsConfig.modelNameLength */
+    bufferSize += 32; /* u8 primitive->wpsConfig.modelNumber[32] */
+    bufferSize += 1;  /* u8 primitive->wpsConfig.modelNumberLength */
+    bufferSize += 32; /* u8 primitive->wpsConfig.serialNumber[32] */
+    bufferSize += 8;  /* u8 primitive->wpsConfig.primDeviceType.deviceDetails[8] */
+    bufferSize += 1;  /* u8 primitive->wpsConfig.secondaryDeviceTypeCount */
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
         {
-            bufferSize += 8; /* CsrUint8 primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails[8] */
+            bufferSize += 8; /* u8 primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails[8] */
         }
     }
     bufferSize += 2;         /* CsrWifiSmeWpsConfigTypeMask primitive->wpsConfig.configMethods */
-    bufferSize += 1;         /* CsrUint8 primitive->wpsConfig.rfBands */
-    bufferSize += 4;         /* CsrUint8 primitive->wpsConfig.osVersion[4] */
+    bufferSize += 1;         /* u8 primitive->wpsConfig.rfBands */
+    bufferSize += 4;         /* u8 primitive->wpsConfig.osVersion[4] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeWpsConfigurationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.wpsVersion);
+    CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.wpsVersion);
     CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.uuid, ((CsrUint16) (16)));
     CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.deviceName, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.deviceNameLength);
+    CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.deviceNameLength);
     CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.manufacturer, ((CsrUint16) (64)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.manufacturerLength);
+    CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.manufacturerLength);
     CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelName, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.modelNameLength);
+    CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.modelNameLength);
     CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelNumber, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.modelNumberLength);
+    CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.modelNumberLength);
     CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.serialNumber, ((CsrUint16) (32)));
     CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.primDeviceType.deviceDetails, ((CsrUint16) (8)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.secondaryDeviceTypeCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.secondaryDeviceTypeCount);
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
@@ -1844,32 +1844,32 @@ CsrUint8* CsrWifiSmeWpsConfigurationReqSer(CsrUint8 *ptr, CsrSize *len, void *ms
         }
     }
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->wpsConfig.configMethods);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.rfBands);
+    CsrUint8Ser(ptr, len, (u8) primitive->wpsConfig.rfBands);
     CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.osVersion, ((CsrUint16) (4)));
     return(ptr);
 }
 
 
-void* CsrWifiSmeWpsConfigurationReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWpsConfigurationReq));
     CsrSize offset;
     offset = 0;
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.wpsVersion, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->wpsConfig.wpsVersion, buffer, &offset);
     CsrMemCpyDes(primitive->wpsConfig.uuid, buffer, &offset, ((CsrUint16) (16)));
     CsrMemCpyDes(primitive->wpsConfig.deviceName, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.deviceNameLength, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->wpsConfig.deviceNameLength, buffer, &offset);
     CsrMemCpyDes(primitive->wpsConfig.manufacturer, buffer, &offset, ((CsrUint16) (64)));
-    CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.manufacturerLength, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->wpsConfig.manufacturerLength, buffer, &offset);
     CsrMemCpyDes(primitive->wpsConfig.modelName, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.modelNameLength, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->wpsConfig.modelNameLength, buffer, &offset);
     CsrMemCpyDes(primitive->wpsConfig.modelNumber, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.modelNumberLength, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->wpsConfig.modelNumberLength, buffer, &offset);
     CsrMemCpyDes(primitive->wpsConfig.serialNumber, buffer, &offset, ((CsrUint16) (32)));
     CsrMemCpyDes(primitive->wpsConfig.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
-    CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.secondaryDeviceTypeCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->wpsConfig.secondaryDeviceTypeCount, buffer, &offset);
     primitive->wpsConfig.secondaryDeviceType = NULL;
     if (primitive->wpsConfig.secondaryDeviceTypeCount)
     {
@@ -1883,7 +1883,7 @@ void* CsrWifiSmeWpsConfigurationReqDes(CsrUint8 *buffer, CsrSize length)
         }
     }
     CsrUint16Des((CsrUint16 *) &primitive->wpsConfig.configMethods, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.rfBands, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->wpsConfig.rfBands, buffer, &offset);
     CsrMemCpyDes(primitive->wpsConfig.osVersion, buffer, &offset, ((CsrUint16) (4)));
 
     return primitive;
@@ -1905,12 +1905,12 @@ CsrSize CsrWifiSmeSetReqSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 4;                     /* CsrUint32 primitive->dataLength */
-    bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+    bufferSize += primitive->dataLength; /* u8 primitive->data */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSetReqSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *)msg;
     *len = 0;
@@ -1924,7 +1924,7 @@ CsrUint8* CsrWifiSmeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeSetReqDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSetReqDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSetReq));
     CsrSize offset;
@@ -1934,7 +1934,7 @@ void* CsrWifiSmeSetReqDes(CsrUint8 *buffer, CsrSize length)
     CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
-        primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+        primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
         CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
     }
     else
@@ -1968,7 +1968,7 @@ CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeAdhocConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeAdhocConfigGetCfm *primitive = (CsrWifiSmeAdhocConfigGetCfm *)msg;
     *len = 0;
@@ -1982,7 +1982,7 @@ CsrUint8* CsrWifiSmeAdhocConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeAdhocConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeAdhocConfigGetCfm *primitive = (CsrWifiSmeAdhocConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigGetCfm));
     CsrSize offset;
@@ -2007,11 +2007,11 @@ CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 98) */
     bufferSize += 2;                                                     /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;                                                     /* CsrResult primitive->status */
-    bufferSize += 32;                                                    /* CsrUint8 primitive->connectionInfo.ssid.ssid[32] */
-    bufferSize += 1;                                                     /* CsrUint8 primitive->connectionInfo.ssid.length */
-    bufferSize += 6;                                                     /* CsrUint8 primitive->connectionInfo.bssid.a[6] */
+    bufferSize += 32;                                                    /* u8 primitive->connectionInfo.ssid.ssid[32] */
+    bufferSize += 1;                                                     /* u8 primitive->connectionInfo.ssid.length */
+    bufferSize += 6;                                                     /* u8 primitive->connectionInfo.bssid.a[6] */
     bufferSize += 1;                                                     /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
-    bufferSize += 1;                                                     /* CsrUint8 primitive->connectionInfo.channelNumber */
+    bufferSize += 1;                                                     /* u8 primitive->connectionInfo.channelNumber */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.channelFrequency */
     bufferSize += 2;                                                     /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
     bufferSize += 2;                                                     /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
@@ -2021,29 +2021,29 @@ CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg)
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
     bufferSize += 1;                                                     /* CsrBool primitive->connectionInfo.reassociation */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
-    bufferSize += primitive->connectionInfo.beaconFrameLength;           /* CsrUint8 primitive->connectionInfo.beaconFrame */
+    bufferSize += primitive->connectionInfo.beaconFrameLength;           /* u8 primitive->connectionInfo.beaconFrame */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
-    bufferSize += primitive->connectionInfo.associationReqFrameLength;   /* CsrUint8 primitive->connectionInfo.associationReqFrame */
+    bufferSize += primitive->connectionInfo.associationReqFrameLength;   /* u8 primitive->connectionInfo.associationReqFrame */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
-    bufferSize += primitive->connectionInfo.associationRspFrameLength;   /* CsrUint8 primitive->connectionInfo.associationRspFrame */
+    bufferSize += primitive->connectionInfo.associationRspFrameLength;   /* u8 primitive->connectionInfo.associationRspFrame */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
-    bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocScanInfoElements */
+    bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
-    bufferSize += 6;                                                     /* CsrUint8 primitive->connectionInfo.assocReqApAddress.a[6] */
+    bufferSize += 6;                                                     /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
-    bufferSize += primitive->connectionInfo.assocReqInfoElementsLength;  /* CsrUint8 primitive->connectionInfo.assocReqInfoElements */
+    bufferSize += primitive->connectionInfo.assocReqInfoElementsLength;  /* u8 primitive->connectionInfo.assocReqInfoElements */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
-    bufferSize += primitive->connectionInfo.assocRspInfoElementsLength;  /* CsrUint8 primitive->connectionInfo.assocRspInfoElements */
+    bufferSize += primitive->connectionInfo.assocRspInfoElementsLength;  /* u8 primitive->connectionInfo.assocRspInfoElements */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Reason primitive->deauthReason */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeAssociationCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *)msg;
     *len = 0;
@@ -2051,18 +2051,18 @@ CsrUint8* CsrWifiSmeAssociationCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
     CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ssid.length);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
     CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.networkType80211);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.channelNumber);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.networkType80211);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.channelNumber);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ifIndex);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.reassociation);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
     if (primitive->connectionInfo.beaconFrameLength)
     {
@@ -2104,7 +2104,7 @@ CsrUint8* CsrWifiSmeAssociationCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void
 }
 
 
-void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAssociationCompleteInd));
     CsrSize offset;
@@ -2114,22 +2114,22 @@ void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
     CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
     CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
     if (primitive->connectionInfo.beaconFrameLength)
     {
-        primitive->connectionInfo.beaconFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
+        primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
         CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
     }
     else
@@ -2139,7 +2139,7 @@ void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationReqFrameLength)
     {
-        primitive->connectionInfo.associationReqFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
+        primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
         CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
     }
     else
@@ -2149,7 +2149,7 @@ void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationRspFrameLength)
     {
-        primitive->connectionInfo.associationRspFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
+        primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
         CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
     }
     else
@@ -2159,7 +2159,7 @@ void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocScanInfoElementsLength)
     {
-        primitive->connectionInfo.assocScanInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
+        primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
         CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
     }
     else
@@ -2172,7 +2172,7 @@ void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocReqInfoElementsLength)
     {
-        primitive->connectionInfo.assocReqInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
+        primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
         CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
     }
     else
@@ -2185,7 +2185,7 @@ void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocRspInfoElementsLength)
     {
-        primitive->connectionInfo.assocRspInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
+        primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
         CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
     }
     else
@@ -2217,14 +2217,14 @@ CsrSize CsrWifiSmeAssociationStartIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 44) */
     bufferSize += 2;  /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 6;  /* CsrUint8 primitive->address.a[6] */
-    bufferSize += 32; /* CsrUint8 primitive->ssid.ssid[32] */
-    bufferSize += 1;  /* CsrUint8 primitive->ssid.length */
+    bufferSize += 6;  /* u8 primitive->address.a[6] */
+    bufferSize += 32; /* u8 primitive->ssid.ssid[32] */
+    bufferSize += 1;  /* u8 primitive->ssid.length */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeAssociationStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeAssociationStartInd *primitive = (CsrWifiSmeAssociationStartInd *)msg;
     *len = 0;
@@ -2232,12 +2232,12 @@ CsrUint8* CsrWifiSmeAssociationStartIndSer(CsrUint8 *ptr, CsrSize *len, void *ms
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
     CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid.length);
+    CsrUint8Ser(ptr, len, (u8) primitive->ssid.length);
     return(ptr);
 }
 
 
-void* CsrWifiSmeAssociationStartIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeAssociationStartInd *primitive = (CsrWifiSmeAssociationStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAssociationStartInd));
     CsrSize offset;
@@ -2247,7 +2247,7 @@ void* CsrWifiSmeAssociationStartIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
     CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->ssid.length, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ssid.length, buffer, &offset);
 
     return primitive;
 }
@@ -2262,27 +2262,27 @@ CsrSize CsrWifiSmeBlacklistCfmSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
-    bufferSize += 1; /* CsrUint8 primitive->getAddressCount */
+    bufferSize += 1; /* u8 primitive->getAddressCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->getAddressCount; i1++)
         {
-            bufferSize += 6; /* CsrUint8 primitive->getAddresses[i1].a[6] */
+            bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeBlacklistCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->getAddressCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->getAddressCount);
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->getAddressCount; i1++)
@@ -2294,7 +2294,7 @@ CsrUint8* CsrWifiSmeBlacklistCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeBlacklistCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeBlacklistCfm));
     CsrSize offset;
@@ -2303,8 +2303,8 @@ void* CsrWifiSmeBlacklistCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->getAddressCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->getAddressCount, buffer, &offset);
     primitive->getAddresses = NULL;
     if (primitive->getAddressCount)
     {
@@ -2338,12 +2338,12 @@ 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 += primitive->calibrationDataLength; /* CsrUint8 primitive->calibrationData */
+    bufferSize += primitive->calibrationDataLength; /* u8 primitive->calibrationData */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeCalibrationDataGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *)msg;
     *len = 0;
@@ -2358,7 +2358,7 @@ CsrUint8* CsrWifiSmeCalibrationDataGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *
 }
 
 
-void* CsrWifiSmeCalibrationDataGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataGetCfm));
     CsrSize offset;
@@ -2369,7 +2369,7 @@ void* CsrWifiSmeCalibrationDataGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->calibrationDataLength, buffer, &offset);
     if (primitive->calibrationDataLength)
     {
-        primitive->calibrationData = (CsrUint8 *)CsrPmemAlloc(primitive->calibrationDataLength);
+        primitive->calibrationData = (u8 *)CsrPmemAlloc(primitive->calibrationDataLength);
         CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((CsrUint16) (primitive->calibrationDataLength)));
     }
     else
@@ -2396,30 +2396,30 @@ CsrSize CsrWifiSmeCcxConfigGetCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 1; /* CsrUint8 primitive->ccxConfig.keepAliveTimeMs */
+    bufferSize += 1; /* u8 primitive->ccxConfig.keepAliveTimeMs */
     bufferSize += 1; /* CsrBool primitive->ccxConfig.apRoamingEnabled */
-    bufferSize += 1; /* CsrUint8 primitive->ccxConfig.measurementsMask */
+    bufferSize += 1; /* u8 primitive->ccxConfig.measurementsMask */
     bufferSize += 1; /* CsrBool primitive->ccxConfig.ccxRadioMgtEnabled */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeCcxConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCcxConfigGetCfm *primitive = (CsrWifiSmeCcxConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.keepAliveTimeMs);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.apRoamingEnabled);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.measurementsMask);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.ccxRadioMgtEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.keepAliveTimeMs);
+    CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.apRoamingEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.measurementsMask);
+    CsrUint8Ser(ptr, len, (u8) primitive->ccxConfig.ccxRadioMgtEnabled);
     return(ptr);
 }
 
 
-void* CsrWifiSmeCcxConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCcxConfigGetCfm *primitive = (CsrWifiSmeCcxConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigGetCfm));
     CsrSize offset;
@@ -2428,10 +2428,10 @@ void* CsrWifiSmeCcxConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.ccxRadioMgtEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->ccxConfig.ccxRadioMgtEnabled, buffer, &offset);
 
     return primitive;
 }
@@ -2448,7 +2448,7 @@ CsrSize CsrWifiSmeCcxConfigSetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeCcxConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCcxConfigSetCfm *primitive = (CsrWifiSmeCcxConfigSetCfm *)msg;
     *len = 0;
@@ -2459,7 +2459,7 @@ CsrUint8* CsrWifiSmeCcxConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCcxConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCcxConfigSetCfm *primitive = (CsrWifiSmeCcxConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigSetCfm));
     CsrSize offset;
@@ -2497,14 +2497,14 @@ CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeCoexConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCoexConfigGetCfm *primitive = (CsrWifiSmeCoexConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexEnableSchemeManagement);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexPeriodicWakeHost);
+    CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexEnableSchemeManagement);
+    CsrUint8Ser(ptr, len, (u8) primitive->coexConfig.coexPeriodicWakeHost);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutDurationMs);
@@ -2521,7 +2521,7 @@ CsrUint8* CsrWifiSmeCoexConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCoexConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCoexConfigGetCfm *primitive = (CsrWifiSmeCoexConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigGetCfm));
     CsrSize offset;
@@ -2529,8 +2529,8 @@ void* CsrWifiSmeCoexConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexPeriodicWakeHost, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->coexConfig.coexPeriodicWakeHost, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
@@ -2568,27 +2568,27 @@ CsrSize CsrWifiSmeCoexInfoGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeCoexInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCoexInfoGetCfm *primitive = (CsrWifiSmeCoexInfoGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.hasTrafficData);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.currentTrafficType);
+    CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.hasTrafficData);
+    CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentTrafficType);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentPeriodMs);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.currentPowerSave);
+    CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentPowerSave);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentCoexPeriodMs);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentCoexLatencyMs);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.hasBtDevice);
+    CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.hasBtDevice);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->coexInfo.currentBlackoutDurationUs);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->coexInfo.currentBlackoutPeriodUs);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.currentCoexScheme);
+    CsrUint8Ser(ptr, len, (u8) primitive->coexInfo.currentCoexScheme);
     return(ptr);
 }
 
 
-void* CsrWifiSmeCoexInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCoexInfoGetCfm *primitive = (CsrWifiSmeCoexInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexInfoGetCfm));
     CsrSize offset;
@@ -2596,16 +2596,16 @@ void* CsrWifiSmeCoexInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->coexInfo.hasTrafficData, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->coexInfo.currentTrafficType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->coexInfo.hasTrafficData, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->coexInfo.currentTrafficType, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentPeriodMs, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->coexInfo.currentPowerSave, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->coexInfo.currentPowerSave, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentCoexPeriodMs, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentCoexLatencyMs, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->coexInfo.hasBtDevice, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->coexInfo.hasBtDevice, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->coexInfo.currentBlackoutDurationUs, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->coexInfo.currentBlackoutPeriodUs, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->coexInfo.currentCoexScheme, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->coexInfo.currentCoexScheme, buffer, &offset);
 
     return primitive;
 }
@@ -2622,7 +2622,7 @@ CsrSize CsrWifiSmeConnectCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeConnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeConnectCfm *primitive = (CsrWifiSmeConnectCfm *)msg;
     *len = 0;
@@ -2633,7 +2633,7 @@ CsrUint8* CsrWifiSmeConnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeConnectCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeConnectCfm *primitive = (CsrWifiSmeConnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectCfm));
     CsrSize offset;
@@ -2655,24 +2655,24 @@ CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 59) */
     bufferSize += 2;                                                                     /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;                                                                     /* CsrResult primitive->status */
-    bufferSize += 32;                                                                    /* CsrUint8 primitive->connectionConfig.ssid.ssid[32] */
-    bufferSize += 1;                                                                     /* CsrUint8 primitive->connectionConfig.ssid.length */
-    bufferSize += 6;                                                                     /* CsrUint8 primitive->connectionConfig.bssid.a[6] */
+    bufferSize += 32;                                                                    /* u8 primitive->connectionConfig.ssid.ssid[32] */
+    bufferSize += 1;                                                                     /* u8 primitive->connectionConfig.ssid.length */
+    bufferSize += 6;                                                                     /* u8 primitive->connectionConfig.bssid.a[6] */
     bufferSize += 1;                                                                     /* CsrWifiSmeBssType primitive->connectionConfig.bssType */
     bufferSize += 1;                                                                     /* CsrWifiSmeRadioIF primitive->connectionConfig.ifIndex */
     bufferSize += 1;                                                                     /* CsrWifiSme80211PrivacyMode primitive->connectionConfig.privacyMode */
     bufferSize += 2;                                                                     /* CsrWifiSmeAuthModeMask primitive->connectionConfig.authModeMask */
     bufferSize += 2;                                                                     /* CsrWifiSmeEncryptionMask primitive->connectionConfig.encryptionModeMask */
     bufferSize += 2;                                                                     /* CsrUint16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
-    bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* CsrUint8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
+    bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* u8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
     bufferSize += 1;                                                                     /* CsrWifiSmeWmmQosInfoMask primitive->connectionConfig.wmmQosInfo */
     bufferSize += 1;                                                                     /* CsrBool primitive->connectionConfig.adhocJoinOnly */
-    bufferSize += 1;                                                                     /* CsrUint8 primitive->connectionConfig.adhocChannel */
+    bufferSize += 1;                                                                     /* u8 primitive->connectionConfig.adhocChannel */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeConnectionConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *)msg;
     *len = 0;
@@ -2680,11 +2680,11 @@ CsrUint8* CsrWifiSmeConnectionConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
     CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ssid.length);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ssid.length);
     CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.bssType);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ifIndex);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.privacyMode);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.bssType);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.ifIndex);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.privacyMode);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.authModeMask);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.encryptionModeMask);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
@@ -2692,14 +2692,14 @@ CsrUint8* CsrWifiSmeConnectionConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void
     {
         CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.wmmQosInfo);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocJoinOnly);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocChannel);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.wmmQosInfo);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocJoinOnly);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionConfig.adhocChannel);
     return(ptr);
 }
 
 
-void* CsrWifiSmeConnectionConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionConfigGetCfm));
     CsrSize offset;
@@ -2709,26 +2709,26 @@ void* CsrWifiSmeConnectionConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
     CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
     CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.bssType, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.bssType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
     if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
     {
-        primitive->connectionConfig.mlmeAssociateReqInformationElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+        primitive->connectionConfig.mlmeAssociateReqInformationElements = (u8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
         CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
     }
     else
     {
         primitive->connectionConfig.mlmeAssociateReqInformationElements = NULL;
     }
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.wmmQosInfo, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocJoinOnly, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocChannel, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.wmmQosInfo, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.adhocJoinOnly, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionConfig.adhocChannel, buffer, &offset);
 
     return primitive;
 }
@@ -2750,11 +2750,11 @@ CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 96) */
     bufferSize += 2;                                                     /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2;                                                     /* CsrResult primitive->status */
-    bufferSize += 32;                                                    /* CsrUint8 primitive->connectionInfo.ssid.ssid[32] */
-    bufferSize += 1;                                                     /* CsrUint8 primitive->connectionInfo.ssid.length */
-    bufferSize += 6;                                                     /* CsrUint8 primitive->connectionInfo.bssid.a[6] */
+    bufferSize += 32;                                                    /* u8 primitive->connectionInfo.ssid.ssid[32] */
+    bufferSize += 1;                                                     /* u8 primitive->connectionInfo.ssid.length */
+    bufferSize += 6;                                                     /* u8 primitive->connectionInfo.bssid.a[6] */
     bufferSize += 1;                                                     /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
-    bufferSize += 1;                                                     /* CsrUint8 primitive->connectionInfo.channelNumber */
+    bufferSize += 1;                                                     /* u8 primitive->connectionInfo.channelNumber */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.channelFrequency */
     bufferSize += 2;                                                     /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
     bufferSize += 2;                                                     /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
@@ -2764,28 +2764,28 @@ CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg)
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
     bufferSize += 1;                                                     /* CsrBool primitive->connectionInfo.reassociation */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
-    bufferSize += primitive->connectionInfo.beaconFrameLength;           /* CsrUint8 primitive->connectionInfo.beaconFrame */
+    bufferSize += primitive->connectionInfo.beaconFrameLength;           /* u8 primitive->connectionInfo.beaconFrame */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
-    bufferSize += primitive->connectionInfo.associationReqFrameLength;   /* CsrUint8 primitive->connectionInfo.associationReqFrame */
+    bufferSize += primitive->connectionInfo.associationReqFrameLength;   /* u8 primitive->connectionInfo.associationReqFrame */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
-    bufferSize += primitive->connectionInfo.associationRspFrameLength;   /* CsrUint8 primitive->connectionInfo.associationRspFrame */
+    bufferSize += primitive->connectionInfo.associationRspFrameLength;   /* u8 primitive->connectionInfo.associationRspFrame */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
-    bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocScanInfoElements */
+    bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
-    bufferSize += 6;                                                     /* CsrUint8 primitive->connectionInfo.assocReqApAddress.a[6] */
+    bufferSize += 6;                                                     /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
-    bufferSize += primitive->connectionInfo.assocReqInfoElementsLength;  /* CsrUint8 primitive->connectionInfo.assocReqInfoElements */
+    bufferSize += primitive->connectionInfo.assocReqInfoElementsLength;  /* u8 primitive->connectionInfo.assocReqInfoElements */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
-    bufferSize += primitive->connectionInfo.assocRspInfoElementsLength;  /* CsrUint8 primitive->connectionInfo.assocRspInfoElements */
+    bufferSize += primitive->connectionInfo.assocRspInfoElementsLength;  /* u8 primitive->connectionInfo.assocRspInfoElements */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeConnectionInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *)msg;
     *len = 0;
@@ -2793,18 +2793,18 @@ CsrUint8* CsrWifiSmeConnectionInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *m
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
     CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ssid.length);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
     CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.networkType80211);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.channelNumber);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.networkType80211);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.channelNumber);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ifIndex);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.reassociation);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
     if (primitive->connectionInfo.beaconFrameLength)
     {
@@ -2845,7 +2845,7 @@ CsrUint8* CsrWifiSmeConnectionInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *m
 }
 
 
-void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionInfoGetCfm));
     CsrSize offset;
@@ -2855,22 +2855,22 @@ void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
     CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
     CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
     if (primitive->connectionInfo.beaconFrameLength)
     {
-        primitive->connectionInfo.beaconFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
+        primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
         CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
     }
     else
@@ -2880,7 +2880,7 @@ void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationReqFrameLength)
     {
-        primitive->connectionInfo.associationReqFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
+        primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
         CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
     }
     else
@@ -2890,7 +2890,7 @@ void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationRspFrameLength)
     {
-        primitive->connectionInfo.associationRspFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
+        primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
         CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
     }
     else
@@ -2900,7 +2900,7 @@ void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocScanInfoElementsLength)
     {
-        primitive->connectionInfo.assocScanInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
+        primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
         CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
     }
     else
@@ -2913,7 +2913,7 @@ void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocReqInfoElementsLength)
     {
-        primitive->connectionInfo.assocReqInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
+        primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
         CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
     }
     else
@@ -2926,7 +2926,7 @@ void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocRspInfoElementsLength)
     {
-        primitive->connectionInfo.assocRspInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
+        primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
         CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
     }
     else
@@ -2963,7 +2963,7 @@ CsrSize CsrWifiSmeConnectionQualityIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeConnectionQualityIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeConnectionQualityInd *primitive = (CsrWifiSmeConnectionQualityInd *)msg;
     *len = 0;
@@ -2975,7 +2975,7 @@ CsrUint8* CsrWifiSmeConnectionQualityIndSer(CsrUint8 *ptr, CsrSize *len, void *m
 }
 
 
-void* CsrWifiSmeConnectionQualityIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeConnectionQualityInd *primitive = (CsrWifiSmeConnectionQualityInd *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionQualityInd));
     CsrSize offset;
@@ -2997,8 +2997,8 @@ CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 101) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 1; /* CsrUint8 primitive->connectionStats.unifiTxDataRate */
-    bufferSize += 1; /* CsrUint8 primitive->connectionStats.unifiRxDataRate */
+    bufferSize += 1; /* u8 primitive->connectionStats.unifiTxDataRate */
+    bufferSize += 1; /* u8 primitive->connectionStats.unifiRxDataRate */
     bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RetryCount */
     bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11MultipleRetryCount */
     bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11AckFailureCount */
@@ -3026,15 +3026,15 @@ CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeConnectionStatsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeConnectionStatsGetCfm *primitive = (CsrWifiSmeConnectionStatsGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionStats.unifiTxDataRate);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionStats.unifiRxDataRate);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionStats.unifiTxDataRate);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionStats.unifiRxDataRate);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RetryCount);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11MultipleRetryCount);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11AckFailureCount);
@@ -3062,7 +3062,7 @@ CsrUint8* CsrWifiSmeConnectionStatsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *
 }
 
 
-void* CsrWifiSmeConnectionStatsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeConnectionStatsGetCfm *primitive = (CsrWifiSmeConnectionStatsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionStatsGetCfm));
     CsrSize offset;
@@ -3071,8 +3071,8 @@ void* CsrWifiSmeConnectionStatsGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionStats.unifiTxDataRate, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionStats.unifiRxDataRate, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionStats.unifiTxDataRate, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionStats.unifiRxDataRate, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RetryCount, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11MultipleRetryCount, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11AckFailureCount, buffer, &offset);
@@ -3112,7 +3112,7 @@ CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeDisconnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeDisconnectCfm *primitive = (CsrWifiSmeDisconnectCfm *)msg;
     *len = 0;
@@ -3123,7 +3123,7 @@ CsrUint8* CsrWifiSmeDisconnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeDisconnectCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeDisconnectCfm *primitive = (CsrWifiSmeDisconnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeDisconnectCfm));
     CsrSize offset;
@@ -3150,20 +3150,20 @@ CsrSize CsrWifiSmeHostConfigGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeHostConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeHostConfigGetCfm *primitive = (CsrWifiSmeHostConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->hostConfig.powerMode);
+    CsrUint8Ser(ptr, len, (u8) primitive->hostConfig.powerMode);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->hostConfig.applicationDataPeriodMs);
     return(ptr);
 }
 
 
-void* CsrWifiSmeHostConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeHostConfigGetCfm *primitive = (CsrWifiSmeHostConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigGetCfm));
     CsrSize offset;
@@ -3172,7 +3172,7 @@ void* CsrWifiSmeHostConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->hostConfig.powerMode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->hostConfig.powerMode, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
 
     return primitive;
@@ -3190,7 +3190,7 @@ CsrSize CsrWifiSmeHostConfigSetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeHostConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeHostConfigSetCfm *primitive = (CsrWifiSmeHostConfigSetCfm *)msg;
     *len = 0;
@@ -3201,7 +3201,7 @@ CsrUint8* CsrWifiSmeHostConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeHostConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeHostConfigSetCfm *primitive = (CsrWifiSmeHostConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigSetCfm));
     CsrSize offset;
@@ -3220,24 +3220,24 @@ CsrSize CsrWifiSmeIbssStationIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
-    bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+    bufferSize += 6; /* u8 primitive->address.a[6] */
     bufferSize += 1; /* CsrBool primitive->isconnected */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeIbssStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeIbssStationInd *primitive = (CsrWifiSmeIbssStationInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->isconnected);
+    CsrUint8Ser(ptr, len, (u8) primitive->isconnected);
     return(ptr);
 }
 
 
-void* CsrWifiSmeIbssStationIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeIbssStationIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeIbssStationInd *primitive = (CsrWifiSmeIbssStationInd *) CsrPmemAlloc(sizeof(CsrWifiSmeIbssStationInd));
     CsrSize offset;
@@ -3245,7 +3245,7 @@ void* CsrWifiSmeIbssStationIndDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->isconnected, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->isconnected, buffer, &offset);
 
     return primitive;
 }
@@ -3260,26 +3260,26 @@ CsrSize CsrWifiSmeKeyCfmSizeof(void *msg)
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
     bufferSize += 1; /* CsrWifiSmeKeyType primitive->keyType */
-    bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->peerMacAddress.a[6] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeKeyCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeKeyCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeKeyCfm *primitive = (CsrWifiSmeKeyCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->keyType);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->keyType);
     CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
     return(ptr);
 }
 
 
-void* CsrWifiSmeKeyCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeKeyCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeKeyCfm *primitive = (CsrWifiSmeKeyCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeKeyCfm));
     CsrSize offset;
@@ -3288,8 +3288,8 @@ void* CsrWifiSmeKeyCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->keyType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->keyType, buffer, &offset);
     CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
 
     return primitive;
@@ -3309,7 +3309,7 @@ CsrSize CsrWifiSmeLinkQualityGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeLinkQualityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeLinkQualityGetCfm *primitive = (CsrWifiSmeLinkQualityGetCfm *)msg;
     *len = 0;
@@ -3322,7 +3322,7 @@ CsrUint8* CsrWifiSmeLinkQualityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeLinkQualityGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeLinkQualityGetCfm *primitive = (CsrWifiSmeLinkQualityGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeLinkQualityGetCfm));
     CsrSize offset;
@@ -3346,11 +3346,11 @@ CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 99) */
     bufferSize += 2;                                                     /* CsrUint16 primitive->interfaceTag */
     bufferSize += 1;                                                     /* CsrWifiSmeMediaStatus primitive->mediaStatus */
-    bufferSize += 32;                                                    /* CsrUint8 primitive->connectionInfo.ssid.ssid[32] */
-    bufferSize += 1;                                                     /* CsrUint8 primitive->connectionInfo.ssid.length */
-    bufferSize += 6;                                                     /* CsrUint8 primitive->connectionInfo.bssid.a[6] */
+    bufferSize += 32;                                                    /* u8 primitive->connectionInfo.ssid.ssid[32] */
+    bufferSize += 1;                                                     /* u8 primitive->connectionInfo.ssid.length */
+    bufferSize += 6;                                                     /* u8 primitive->connectionInfo.bssid.a[6] */
     bufferSize += 1;                                                     /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
-    bufferSize += 1;                                                     /* CsrUint8 primitive->connectionInfo.channelNumber */
+    bufferSize += 1;                                                     /* u8 primitive->connectionInfo.channelNumber */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.channelFrequency */
     bufferSize += 2;                                                     /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
     bufferSize += 2;                                                     /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
@@ -3360,49 +3360,49 @@ CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg)
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
     bufferSize += 1;                                                     /* CsrBool primitive->connectionInfo.reassociation */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
-    bufferSize += primitive->connectionInfo.beaconFrameLength;           /* CsrUint8 primitive->connectionInfo.beaconFrame */
+    bufferSize += primitive->connectionInfo.beaconFrameLength;           /* u8 primitive->connectionInfo.beaconFrame */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
-    bufferSize += primitive->connectionInfo.associationReqFrameLength;   /* CsrUint8 primitive->connectionInfo.associationReqFrame */
+    bufferSize += primitive->connectionInfo.associationReqFrameLength;   /* u8 primitive->connectionInfo.associationReqFrame */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
-    bufferSize += primitive->connectionInfo.associationRspFrameLength;   /* CsrUint8 primitive->connectionInfo.associationRspFrame */
+    bufferSize += primitive->connectionInfo.associationRspFrameLength;   /* u8 primitive->connectionInfo.associationRspFrame */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
-    bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocScanInfoElements */
+    bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* u8 primitive->connectionInfo.assocScanInfoElements */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
-    bufferSize += 6;                                                     /* CsrUint8 primitive->connectionInfo.assocReqApAddress.a[6] */
+    bufferSize += 6;                                                     /* u8 primitive->connectionInfo.assocReqApAddress.a[6] */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
-    bufferSize += primitive->connectionInfo.assocReqInfoElementsLength;  /* CsrUint8 primitive->connectionInfo.assocReqInfoElements */
+    bufferSize += primitive->connectionInfo.assocReqInfoElementsLength;  /* u8 primitive->connectionInfo.assocReqInfoElements */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
     bufferSize += 2;                                                     /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
-    bufferSize += primitive->connectionInfo.assocRspInfoElementsLength;  /* CsrUint8 primitive->connectionInfo.assocRspInfoElements */
+    bufferSize += primitive->connectionInfo.assocRspInfoElementsLength;  /* u8 primitive->connectionInfo.assocRspInfoElements */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Reason primitive->disassocReason */
     bufferSize += 2;                                                     /* CsrWifiSmeIEEE80211Reason primitive->deauthReason */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeMediaStatusIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->mediaStatus);
+    CsrUint8Ser(ptr, len, (u8) primitive->mediaStatus);
     CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ssid.length);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ssid.length);
     CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.networkType80211);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.channelNumber);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.networkType80211);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.channelNumber);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ifIndex);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.ifIndex);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.reassociation);
+    CsrUint8Ser(ptr, len, (u8) primitive->connectionInfo.reassociation);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
     if (primitive->connectionInfo.beaconFrameLength)
     {
@@ -3445,7 +3445,7 @@ CsrUint8* CsrWifiSmeMediaStatusIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *) CsrPmemAlloc(sizeof(CsrWifiSmeMediaStatusInd));
     CsrSize offset;
@@ -3453,24 +3453,24 @@ void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->mediaStatus, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->mediaStatus, buffer, &offset);
     CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
     CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
     if (primitive->connectionInfo.beaconFrameLength)
     {
-        primitive->connectionInfo.beaconFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
+        primitive->connectionInfo.beaconFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
         CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
     }
     else
@@ -3480,7 +3480,7 @@ void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationReqFrameLength)
     {
-        primitive->connectionInfo.associationReqFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
+        primitive->connectionInfo.associationReqFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
         CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
     }
     else
@@ -3490,7 +3490,7 @@ void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
     if (primitive->connectionInfo.associationRspFrameLength)
     {
-        primitive->connectionInfo.associationRspFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
+        primitive->connectionInfo.associationRspFrame = (u8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
         CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
     }
     else
@@ -3500,7 +3500,7 @@ void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocScanInfoElementsLength)
     {
-        primitive->connectionInfo.assocScanInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
+        primitive->connectionInfo.assocScanInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
         CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
     }
     else
@@ -3513,7 +3513,7 @@ void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocReqInfoElementsLength)
     {
-        primitive->connectionInfo.assocReqInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
+        primitive->connectionInfo.assocReqInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
         CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
     }
     else
@@ -3526,7 +3526,7 @@ void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
     if (primitive->connectionInfo.assocRspInfoElementsLength)
     {
-        primitive->connectionInfo.assocRspInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
+        primitive->connectionInfo.assocRspInfoElements = (u8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
         CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
     }
     else
@@ -3560,7 +3560,7 @@ CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrBool primitive->mibConfig.unifiFixMaxTxDataRate */
-    bufferSize += 1; /* CsrUint8 primitive->mibConfig.unifiFixTxDataRate */
+    bufferSize += 1; /* u8 primitive->mibConfig.unifiFixTxDataRate */
     bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11RtsThreshold */
     bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11FragmentationThreshold */
     bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11CurrentTxPowerLevel */
@@ -3568,14 +3568,14 @@ CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeMibConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMibConfigGetCfm *primitive = (CsrWifiSmeMibConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixMaxTxDataRate);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixTxDataRate);
+    CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixMaxTxDataRate);
+    CsrUint8Ser(ptr, len, (u8) primitive->mibConfig.unifiFixTxDataRate);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11RtsThreshold);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11FragmentationThreshold);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11CurrentTxPowerLevel);
@@ -3583,7 +3583,7 @@ CsrUint8* CsrWifiSmeMibConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMibConfigGetCfm *primitive = (CsrWifiSmeMibConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigGetCfm));
     CsrSize offset;
@@ -3591,8 +3591,8 @@ void* CsrWifiSmeMibConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixTxDataRate, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->mibConfig.unifiFixTxDataRate, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
@@ -3609,12 +3609,12 @@ 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 += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+    bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeMibGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *)msg;
     *len = 0;
@@ -3629,7 +3629,7 @@ CsrUint8* CsrWifiSmeMibGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetCfm));
     CsrSize offset;
@@ -3640,7 +3640,7 @@ void* CsrWifiSmeMibGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
     if (primitive->mibAttributeLength)
     {
-        primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+        primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
         CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
     }
     else
@@ -3668,12 +3668,12 @@ 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 += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+    bufferSize += primitive->mibAttributeLength; /* u8 primitive->mibAttribute */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeMibGetNextCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *)msg;
     *len = 0;
@@ -3688,7 +3688,7 @@ CsrUint8* CsrWifiSmeMibGetNextCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeMibGetNextCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetNextCfm));
     CsrSize offset;
@@ -3699,7 +3699,7 @@ void* CsrWifiSmeMibGetNextCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
     if (primitive->mibAttributeLength)
     {
-        primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+        primitive->mibAttribute = (u8 *)CsrPmemAlloc(primitive->mibAttributeLength);
         CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
     }
     else
@@ -3727,27 +3727,27 @@ CsrSize CsrWifiSmeMicFailureIndSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 1; /* CsrBool primitive->secondFailure */
     bufferSize += 2; /* CsrUint16 primitive->count */
-    bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+    bufferSize += 6; /* u8 primitive->address.a[6] */
     bufferSize += 1; /* CsrWifiSmeKeyType primitive->keyType */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMicFailureInd *primitive = (CsrWifiSmeMicFailureInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->secondFailure);
+    CsrUint8Ser(ptr, len, (u8) primitive->secondFailure);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->count);
     CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->keyType);
+    CsrUint8Ser(ptr, len, (u8) primitive->keyType);
     return(ptr);
 }
 
 
-void* CsrWifiSmeMicFailureIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMicFailureIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMicFailureInd *primitive = (CsrWifiSmeMicFailureInd *) CsrPmemAlloc(sizeof(CsrWifiSmeMicFailureInd));
     CsrSize offset;
@@ -3755,10 +3755,10 @@ void* CsrWifiSmeMicFailureIndDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->secondFailure, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->secondFailure, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->count, buffer, &offset);
     CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
-    CsrUint8Des((CsrUint8 *) &primitive->keyType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->keyType, buffer, &offset);
 
     return primitive;
 }
@@ -3773,27 +3773,27 @@ CsrSize CsrWifiSmeMulticastAddressCfmSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
-    bufferSize += 1; /* CsrUint8 primitive->getAddressesCount */
+    bufferSize += 1; /* u8 primitive->getAddressesCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
         {
-            bufferSize += 6; /* CsrUint8 primitive->getAddresses[i1].a[6] */
+            bufferSize += 6; /* u8 primitive->getAddresses[i1].a[6] */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeMulticastAddressCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->getAddressesCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->getAddressesCount);
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
@@ -3805,7 +3805,7 @@ CsrUint8* CsrWifiSmeMulticastAddressCfmSer(CsrUint8 *ptr, CsrSize *len, void *ms
 }
 
 
-void* CsrWifiSmeMulticastAddressCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMulticastAddressCfm));
     CsrSize offset;
@@ -3814,8 +3814,8 @@ void* CsrWifiSmeMulticastAddressCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->getAddressesCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->getAddressesCount, buffer, &offset);
     primitive->getAddresses = NULL;
     if (primitive->getAddressesCount)
     {
@@ -3852,7 +3852,7 @@ CsrSize CsrWifiSmePacketFilterSetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmePacketFilterSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmePacketFilterSetCfm *primitive = (CsrWifiSmePacketFilterSetCfm *)msg;
     *len = 0;
@@ -3863,7 +3863,7 @@ CsrUint8* CsrWifiSmePacketFilterSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg
 }
 
 
-void* CsrWifiSmePacketFilterSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmePacketFilterSetCfm *primitive = (CsrWifiSmePacketFilterSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePacketFilterSetCfm));
     CsrSize offset;
@@ -3883,12 +3883,12 @@ CsrSize CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 6; /* CsrUint8 primitive->permanentMacAddress.a[6] */
+    bufferSize += 6; /* u8 primitive->permanentMacAddress.a[6] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmePermanentMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmePermanentMacAddressGetCfm *primitive = (CsrWifiSmePermanentMacAddressGetCfm *)msg;
     *len = 0;
@@ -3899,7 +3899,7 @@ CsrUint8* CsrWifiSmePermanentMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, vo
 }
 
 
-void* CsrWifiSmePermanentMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmePermanentMacAddressGetCfm *primitive = (CsrWifiSmePermanentMacAddressGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePermanentMacAddressGetCfm));
     CsrSize offset;
@@ -3920,12 +3920,12 @@ CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
-    bufferSize += 1; /* CsrUint8 primitive->pmkidCandidatesCount */
+    bufferSize += 1; /* u8 primitive->pmkidCandidatesCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
         {
-            bufferSize += 6; /* CsrUint8 primitive->pmkidCandidates[i1].bssid.a[6] */
+            bufferSize += 6; /* u8 primitive->pmkidCandidates[i1].bssid.a[6] */
             bufferSize += 1; /* CsrBool primitive->pmkidCandidates[i1].preAuthAllowed */
         }
     }
@@ -3933,26 +3933,26 @@ CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmePmkidCandidateListIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->pmkidCandidatesCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->pmkidCandidatesCount);
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
         {
             CsrMemCpySer(ptr, len, (const void *) primitive->pmkidCandidates[i1].bssid.a, ((CsrUint16) (6)));
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->pmkidCandidates[i1].preAuthAllowed);
+            CsrUint8Ser(ptr, len, (u8) primitive->pmkidCandidates[i1].preAuthAllowed);
         }
     }
     return(ptr);
 }
 
 
-void* CsrWifiSmePmkidCandidateListIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidCandidateListInd));
     CsrSize offset;
@@ -3960,7 +3960,7 @@ void* CsrWifiSmePmkidCandidateListIndDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->pmkidCandidatesCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->pmkidCandidatesCount, buffer, &offset);
     primitive->pmkidCandidates = NULL;
     if (primitive->pmkidCandidatesCount)
     {
@@ -3971,7 +3971,7 @@ void* CsrWifiSmePmkidCandidateListIndDes(CsrUint8 *buffer, CsrSize length)
         for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
         {
             CsrMemCpyDes(primitive->pmkidCandidates[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
-            CsrUint8Des((CsrUint8 *) &primitive->pmkidCandidates[i1].preAuthAllowed, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->pmkidCandidates[i1].preAuthAllowed, buffer, &offset);
         }
     }
 
@@ -3996,28 +3996,28 @@ CsrSize CsrWifiSmePmkidCfmSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
-    bufferSize += 1; /* CsrUint8 primitive->getPmkidsCount */
+    bufferSize += 1; /* u8 primitive->getPmkidsCount */
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
         {
-            bufferSize += 6;  /* CsrUint8 primitive->getPmkids[i1].bssid.a[6] */
-            bufferSize += 16; /* CsrUint8 primitive->getPmkids[i1].pmkid[16] */
+            bufferSize += 6;  /* u8 primitive->getPmkids[i1].bssid.a[6] */
+            bufferSize += 16; /* u8 primitive->getPmkids[i1].pmkid[16] */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmePmkidCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePmkidCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->getPmkidsCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->action);
+    CsrUint8Ser(ptr, len, (u8) primitive->getPmkidsCount);
     {
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
@@ -4030,7 +4030,7 @@ CsrUint8* CsrWifiSmePmkidCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmePmkidCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePmkidCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidCfm));
     CsrSize offset;
@@ -4039,8 +4039,8 @@ void* CsrWifiSmePmkidCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->getPmkidsCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->action, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->getPmkidsCount, buffer, &offset);
     primitive->getPmkids = NULL;
     if (primitive->getPmkidsCount)
     {
@@ -4077,31 +4077,31 @@ CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg)
     bufferSize += 2; /* CsrUint16 primitive->powerConfig.listenIntervalTu */
     bufferSize += 1; /* CsrBool primitive->powerConfig.rxDtims */
     bufferSize += 1; /* CsrWifiSmeD3AutoScanMode primitive->powerConfig.d3AutoScanMode */
-    bufferSize += 1; /* CsrUint8 primitive->powerConfig.clientTrafficWindow */
+    bufferSize += 1; /* u8 primitive->powerConfig.clientTrafficWindow */
     bufferSize += 1; /* CsrBool primitive->powerConfig.opportunisticPowerSave */
     bufferSize += 1; /* CsrBool primitive->powerConfig.noticeOfAbsence */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmePowerConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmePowerConfigGetCfm *primitive = (CsrWifiSmePowerConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.powerSaveLevel);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.powerSaveLevel);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->powerConfig.listenIntervalTu);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.rxDtims);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.d3AutoScanMode);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.clientTrafficWindow);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.opportunisticPowerSave);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.noticeOfAbsence);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.rxDtims);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.d3AutoScanMode);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.clientTrafficWindow);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.opportunisticPowerSave);
+    CsrUint8Ser(ptr, len, (u8) primitive->powerConfig.noticeOfAbsence);
     return(ptr);
 }
 
 
-void* CsrWifiSmePowerConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmePowerConfigGetCfm *primitive = (CsrWifiSmePowerConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigGetCfm));
     CsrSize offset;
@@ -4109,13 +4109,13 @@ void* CsrWifiSmePowerConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.opportunisticPowerSave, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->powerConfig.noticeOfAbsence, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.opportunisticPowerSave, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->powerConfig.noticeOfAbsence, buffer, &offset);
 
     return primitive;
 }
@@ -4130,26 +4130,26 @@ CsrSize CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg)
     bufferSize += 1; /* CsrBool primitive->regDomInfo.dot11MultiDomainCapabilityImplemented */
     bufferSize += 1; /* CsrBool primitive->regDomInfo.dot11MultiDomainCapabilityEnabled */
     bufferSize += 1; /* CsrWifiSmeRegulatoryDomain primitive->regDomInfo.currentRegulatoryDomain */
-    bufferSize += 2; /* CsrUint8 primitive->regDomInfo.currentCountryCode[2] */
+    bufferSize += 2; /* u8 primitive->regDomInfo.currentCountryCode[2] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeRegulatoryDomainInfoGetCfm *primitive = (CsrWifiSmeRegulatoryDomainInfoGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->regDomInfo.dot11MultiDomainCapabilityImplemented);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->regDomInfo.dot11MultiDomainCapabilityEnabled);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->regDomInfo.currentRegulatoryDomain);
+    CsrUint8Ser(ptr, len, (u8) primitive->regDomInfo.dot11MultiDomainCapabilityImplemented);
+    CsrUint8Ser(ptr, len, (u8) primitive->regDomInfo.dot11MultiDomainCapabilityEnabled);
+    CsrUint8Ser(ptr, len, (u8) primitive->regDomInfo.currentRegulatoryDomain);
     CsrMemCpySer(ptr, len, (const void *) primitive->regDomInfo.currentCountryCode, ((CsrUint16) (2)));
     return(ptr);
 }
 
 
-void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeRegulatoryDomainInfoGetCfm *primitive = (CsrWifiSmeRegulatoryDomainInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRegulatoryDomainInfoGetCfm));
     CsrSize offset;
@@ -4157,9 +4157,9 @@ void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityImplemented, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityEnabled, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->regDomInfo.currentRegulatoryDomain, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityImplemented, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityEnabled, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->regDomInfo.currentRegulatoryDomain, buffer, &offset);
     CsrMemCpyDes(primitive->regDomInfo.currentCountryCode, buffer, &offset, ((CsrUint16) (2)));
 
     return primitive;
@@ -4177,7 +4177,7 @@ CsrSize CsrWifiSmeRoamCompleteIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeRoamCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeRoamCompleteInd *primitive = (CsrWifiSmeRoamCompleteInd *)msg;
     *len = 0;
@@ -4188,7 +4188,7 @@ CsrUint8* CsrWifiSmeRoamCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeRoamCompleteIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeRoamCompleteInd *primitive = (CsrWifiSmeRoamCompleteInd *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamCompleteInd));
     CsrSize offset;
@@ -4214,19 +4214,19 @@ CsrSize CsrWifiSmeRoamStartIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeRoamStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeRoamStartInd *primitive = (CsrWifiSmeRoamStartInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamReason);
+    CsrUint8Ser(ptr, len, (u8) primitive->roamReason);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->reason80211);
     return(ptr);
 }
 
 
-void* CsrWifiSmeRoamStartIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamStartIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeRoamStartInd *primitive = (CsrWifiSmeRoamStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamStartInd));
     CsrSize offset;
@@ -4234,7 +4234,7 @@ void* CsrWifiSmeRoamStartIndDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->roamReason, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->roamReason, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->reason80211, buffer, &offset);
 
     return primitive;
@@ -4260,7 +4260,7 @@ CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg)
     }
     bufferSize += 1;         /* CsrBool primitive->roamingConfig.disableSmoothRoaming */
     bufferSize += 1;         /* CsrBool primitive->roamingConfig.disableRoamScans */
-    bufferSize += 1;         /* CsrUint8 primitive->roamingConfig.reconnectLimit */
+    bufferSize += 1;         /* u8 primitive->roamingConfig.reconnectLimit */
     bufferSize += 2;         /* CsrUint16 primitive->roamingConfig.reconnectLimitIntervalMs */
     {
         CsrUint16 i2;
@@ -4278,7 +4278,7 @@ CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeRoamingConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeRoamingConfigGetCfm *primitive = (CsrWifiSmeRoamingConfigGetCfm *)msg;
     *len = 0;
@@ -4295,9 +4295,9 @@ CsrUint8* CsrWifiSmeRoamingConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *ms
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
         }
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableSmoothRoaming);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableRoamScans);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.reconnectLimit);
+    CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableSmoothRoaming);
+    CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.disableRoamScans);
+    CsrUint8Ser(ptr, len, (u8) primitive->roamingConfig.reconnectLimit);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.reconnectLimitIntervalMs);
     {
         CsrUint16 i2;
@@ -4315,7 +4315,7 @@ CsrUint8* CsrWifiSmeRoamingConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *ms
 }
 
 
-void* CsrWifiSmeRoamingConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeRoamingConfigGetCfm *primitive = (CsrWifiSmeRoamingConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigGetCfm));
     CsrSize offset;
@@ -4334,9 +4334,9 @@ void* CsrWifiSmeRoamingConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
             CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
         }
     }
-    CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.reconnectLimit, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->roamingConfig.reconnectLimit, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
     {
         CsrUint16 i2;
@@ -4366,7 +4366,7 @@ CsrSize CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeRoamingConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeRoamingConfigSetCfm *primitive = (CsrWifiSmeRoamingConfigSetCfm *)msg;
     *len = 0;
@@ -4377,7 +4377,7 @@ CsrUint8* CsrWifiSmeRoamingConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *ms
 }
 
 
-void* CsrWifiSmeRoamingConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeRoamingConfigSetCfm *primitive = (CsrWifiSmeRoamingConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigSetCfm));
     CsrSize offset;
@@ -4419,12 +4419,12 @@ CsrSize CsrWifiSmeScanConfigGetCfmSizeof(void *msg)
     bufferSize += 1;                                             /* CsrInt8 primitive->scanConfig.lowSnrThreshold */
     bufferSize += 1;                                             /* CsrInt8 primitive->scanConfig.deltaSnrThreshold */
     bufferSize += 2;                                             /* CsrUint16 primitive->scanConfig.passiveChannelListCount */
-    bufferSize += primitive->scanConfig.passiveChannelListCount; /* CsrUint8 primitive->scanConfig.passiveChannelList */
+    bufferSize += primitive->scanConfig.passiveChannelListCount; /* u8 primitive->scanConfig.passiveChannelList */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeScanConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *)msg;
     *len = 0;
@@ -4442,14 +4442,14 @@ CsrUint8* CsrWifiSmeScanConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
         }
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.disableAutonomousScans);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.disableAutonomousScans);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.maxResults);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highRssiThreshold);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowRssiThreshold);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaRssiThreshold);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highSnrThreshold);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowSnrThreshold);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaSnrThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highRssiThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowRssiThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaRssiThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.highSnrThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.lowSnrThreshold);
+    CsrUint8Ser(ptr, len, (u8) primitive->scanConfig.deltaSnrThreshold);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.passiveChannelListCount);
     if (primitive->scanConfig.passiveChannelListCount)
     {
@@ -4459,7 +4459,7 @@ CsrUint8* CsrWifiSmeScanConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeScanConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigGetCfm));
     CsrSize offset;
@@ -4479,18 +4479,18 @@ void* CsrWifiSmeScanConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
             CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
         }
     }
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->scanConfig.maxResults, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaSnrThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->scanConfig.deltaSnrThreshold, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
     if (primitive->scanConfig.passiveChannelListCount)
     {
-        primitive->scanConfig.passiveChannelList = (CsrUint8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
+        primitive->scanConfig.passiveChannelList = (u8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
         CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
     }
     else
@@ -4516,72 +4516,72 @@ CsrSize CsrWifiSmeScanResultIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 149) */
-    bufferSize += 32;                                          /* CsrUint8 primitive->result.ssid.ssid[32] */
-    bufferSize += 1;                                           /* CsrUint8 primitive->result.ssid.length */
-    bufferSize += 6;                                           /* CsrUint8 primitive->result.bssid.a[6] */
+    bufferSize += 32;                                          /* u8 primitive->result.ssid.ssid[32] */
+    bufferSize += 1;                                           /* u8 primitive->result.ssid.length */
+    bufferSize += 6;                                           /* u8 primitive->result.bssid.a[6] */
     bufferSize += 2;                                           /* CsrInt16 primitive->result.rssi */
     bufferSize += 2;                                           /* CsrInt16 primitive->result.snr */
     bufferSize += 1;                                           /* CsrWifiSmeRadioIF primitive->result.ifIndex */
     bufferSize += 2;                                           /* CsrUint16 primitive->result.beaconPeriodTu */
-    bufferSize += 8;                                           /* CsrUint8 primitive->result.timeStamp.data[8] */
-    bufferSize += 8;                                           /* CsrUint8 primitive->result.localTime.data[8] */
+    bufferSize += 8;                                           /* u8 primitive->result.timeStamp.data[8] */
+    bufferSize += 8;                                           /* u8 primitive->result.localTime.data[8] */
     bufferSize += 2;                                           /* CsrUint16 primitive->result.channelFrequency */
     bufferSize += 2;                                           /* CsrUint16 primitive->result.capabilityInformation */
-    bufferSize += 1;                                           /* CsrUint8 primitive->result.channelNumber */
+    bufferSize += 1;                                           /* u8 primitive->result.channelNumber */
     bufferSize += 1;                                           /* CsrWifiSmeBasicUsability primitive->result.usability */
     bufferSize += 1;                                           /* CsrWifiSmeBssType primitive->result.bssType */
     bufferSize += 2;                                           /* CsrUint16 primitive->result.informationElementsLength */
-    bufferSize += primitive->result.informationElementsLength; /* CsrUint8 primitive->result.informationElements */
+    bufferSize += primitive->result.informationElementsLength; /* u8 primitive->result.informationElements */
     bufferSize += 1;                                           /* CsrWifiSmeP2pRole primitive->result.p2pDeviceRole */
     switch (primitive->result.p2pDeviceRole)
     {
         case CSR_WIFI_SME_P2P_ROLE_CLI:
-            bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.reservedCli.empty */
+            bufferSize += 1; /* u8 primitive->result.deviceInfo.reservedCli.empty */
             break;
         case CSR_WIFI_SME_P2P_ROLE_GO:
             bufferSize += 1; /* CsrWifiSmeP2pGroupCapabilityMask primitive->result.deviceInfo.groupInfo.groupCapability */
-            bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
-            bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2pClientInfoCount */
+            bufferSize += 6; /* u8 primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
+            bufferSize += 1; /* u8 primitive->result.deviceInfo.groupInfo.p2pClientInfoCount */
             {
                 CsrUint16 i4;
                 for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                 {
-                    bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
-                    bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a[6] */
+                    bufferSize += 6; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
+                    bufferSize += 6; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a[6] */
                     bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods */
                     bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap */
-                    bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
-                    bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
+                    bufferSize += 8; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
+                    bufferSize += 1; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
                     {
                         CsrUint16 i6;
                         for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
                         {
-                            bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
+                            bufferSize += 8; /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
                         }
                     }
-                    bufferSize += 32;        /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName[32] */
-                    bufferSize += 1;         /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength */
+                    bufferSize += 32;        /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName[32] */
+                    bufferSize += 1;         /* u8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength */
                 }
             }
             break;
         case CSR_WIFI_SME_P2P_ROLE_NONE:
-            bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.reservedNone.empty */
+            bufferSize += 1; /* u8 primitive->result.deviceInfo.reservedNone.empty */
             break;
         case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
-            bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a[6] */
+            bufferSize += 6; /* u8 primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a[6] */
             bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->result.deviceInfo.standalonedevInfo.configMethods */
             bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap */
-            bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
-            bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
+            bufferSize += 8; /* u8 primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
+            bufferSize += 1; /* u8 primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
             {
                 CsrUint16 i4;
                 for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
                 {
-                    bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
+                    bufferSize += 8; /* u8 primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
                 }
             }
-            bufferSize += 32;        /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.deviceName[32] */
-            bufferSize += 1;         /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.deviceNameLength */
+            bufferSize += 32;        /* u8 primitive->result.deviceInfo.standalonedevInfo.deviceName[32] */
+            bufferSize += 1;         /* u8 primitive->result.deviceInfo.standalonedevInfo.deviceNameLength */
             break;
         default:
             break;
@@ -4590,40 +4590,40 @@ CsrSize CsrWifiSmeScanResultIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeScanResultIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrMemCpySer(ptr, len, (const void *) primitive->result.ssid.ssid, ((CsrUint16) (32)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.ssid.length);
+    CsrUint8Ser(ptr, len, (u8) primitive->result.ssid.length);
     CsrMemCpySer(ptr, len, (const void *) primitive->result.bssid.a, ((CsrUint16) (6)));
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.rssi);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.snr);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.ifIndex);
+    CsrUint8Ser(ptr, len, (u8) primitive->result.ifIndex);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.beaconPeriodTu);
     CsrMemCpySer(ptr, len, (const void *) primitive->result.timeStamp.data, ((CsrUint16) (8)));
     CsrMemCpySer(ptr, len, (const void *) primitive->result.localTime.data, ((CsrUint16) (8)));
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.channelFrequency);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.capabilityInformation);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.channelNumber);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.usability);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.bssType);
+    CsrUint8Ser(ptr, len, (u8) primitive->result.channelNumber);
+    CsrUint8Ser(ptr, len, (u8) primitive->result.usability);
+    CsrUint8Ser(ptr, len, (u8) primitive->result.bssType);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.informationElementsLength);
     if (primitive->result.informationElementsLength)
     {
         CsrMemCpySer(ptr, len, (const void *) primitive->result.informationElements, ((CsrUint16) (primitive->result.informationElementsLength)));
     }
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.p2pDeviceRole);
+    CsrUint8Ser(ptr, len, (u8) primitive->result.p2pDeviceRole);
     switch (primitive->result.p2pDeviceRole)
     {
         case CSR_WIFI_SME_P2P_ROLE_CLI:
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.reservedCli.empty);
+            CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.reservedCli.empty);
             break;
         case CSR_WIFI_SME_P2P_ROLE_GO:
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.groupCapability);
+            CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.groupCapability);
             CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, ((CsrUint16) (6)));
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2pClientInfoCount);
+            CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2pClientInfoCount);
             {
                 CsrUint16 i4;
                 for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
@@ -4631,9 +4631,9 @@ CsrUint8* CsrWifiSmeScanResultIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
                     CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((CsrUint16) (6)));
                     CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((CsrUint16) (6)));
                     CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
+                    CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
                     CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
+                    CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
                     {
                         CsrUint16 i6;
                         for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
@@ -4642,19 +4642,19 @@ CsrUint8* CsrWifiSmeScanResultIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
                         }
                     }
                     CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((CsrUint16) (32)));
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
+                    CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
                 }
             }
             break;
         case CSR_WIFI_SME_P2P_ROLE_NONE:
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.reservedNone.empty);
+            CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.reservedNone.empty);
             break;
         case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
             CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, ((CsrUint16) (6)));
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.deviceInfo.standalonedevInfo.configMethods);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap);
+            CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap);
             CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
+            CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
             {
                 CsrUint16 i4;
                 for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
@@ -4663,7 +4663,7 @@ CsrUint8* CsrWifiSmeScanResultIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
                 }
             }
             CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceName, ((CsrUint16) (32)));
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.standalonedevInfo.deviceNameLength);
+            CsrUint8Ser(ptr, len, (u8) primitive->result.deviceInfo.standalonedevInfo.deviceNameLength);
             break;
         default:
             break;
@@ -4672,7 +4672,7 @@ CsrUint8* CsrWifiSmeScanResultIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeScanResultIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultInd));
     CsrSize offset;
@@ -4680,39 +4680,39 @@ void* CsrWifiSmeScanResultIndDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrMemCpyDes(primitive->result.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
-    CsrUint8Des((CsrUint8 *) &primitive->result.ssid.length, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->result.ssid.length, buffer, &offset);
     CsrMemCpyDes(primitive->result.bssid.a, buffer, &offset, ((CsrUint16) (6)));
     CsrUint16Des((CsrUint16 *) &primitive->result.rssi, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->result.snr, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->result.ifIndex, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->result.ifIndex, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->result.beaconPeriodTu, buffer, &offset);
     CsrMemCpyDes(primitive->result.timeStamp.data, buffer, &offset, ((CsrUint16) (8)));
     CsrMemCpyDes(primitive->result.localTime.data, buffer, &offset, ((CsrUint16) (8)));
     CsrUint16Des((CsrUint16 *) &primitive->result.channelFrequency, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->result.capabilityInformation, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->result.channelNumber, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->result.usability, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->result.bssType, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->result.channelNumber, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->result.usability, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->result.bssType, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->result.informationElementsLength, buffer, &offset);
     if (primitive->result.informationElementsLength)
     {
-        primitive->result.informationElements = (CsrUint8 *)CsrPmemAlloc(primitive->result.informationElementsLength);
+        primitive->result.informationElements = (u8 *)CsrPmemAlloc(primitive->result.informationElementsLength);
         CsrMemCpyDes(primitive->result.informationElements, buffer, &offset, ((CsrUint16) (primitive->result.informationElementsLength)));
     }
     else
     {
         primitive->result.informationElements = NULL;
     }
-    CsrUint8Des((CsrUint8 *) &primitive->result.p2pDeviceRole, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->result.p2pDeviceRole, buffer, &offset);
     switch (primitive->result.p2pDeviceRole)
     {
         case CSR_WIFI_SME_P2P_ROLE_CLI:
-            CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.reservedCli.empty, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->result.deviceInfo.reservedCli.empty, buffer, &offset);
             break;
         case CSR_WIFI_SME_P2P_ROLE_GO:
-            CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.groupCapability, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.groupCapability, buffer, &offset);
             CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
-            CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
             primitive->result.deviceInfo.groupInfo.p2PClientInfo = NULL;
             if (primitive->result.deviceInfo.groupInfo.p2pClientInfoCount)
             {
@@ -4725,9 +4725,9 @@ void* CsrWifiSmeScanResultIndDes(CsrUint8 *buffer, CsrSize length)
                     CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((CsrUint16) (6)));
                     CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
                     CsrUint16Des((CsrUint16 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
-                    CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, buffer, &offset);
                     CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
-                    CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
                     primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = NULL;
                     if (primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount)
                     {
@@ -4741,19 +4741,19 @@ void* CsrWifiSmeScanResultIndDes(CsrUint8 *buffer, CsrSize length)
                         }
                     }
                     CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
-                    CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
                 }
             }
             break;
         case CSR_WIFI_SME_P2P_ROLE_NONE:
-            CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.reservedNone.empty, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->result.deviceInfo.reservedNone.empty, buffer, &offset);
             break;
         case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
             CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
             CsrUint16Des((CsrUint16 *) &primitive->result.deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
             CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
-            CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
             primitive->result.deviceInfo.standalonedevInfo.secDeviceType = NULL;
             if (primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount)
             {
@@ -4767,7 +4767,7 @@ void* CsrWifiSmeScanResultIndDes(CsrUint8 *buffer, CsrSize length)
                 }
             }
             CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
-            CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->result.deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
             break;
         default:
             break;
@@ -4815,72 +4815,72 @@ CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
         CsrUint16 i1;
         for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
         {
-            bufferSize += 32;                                                   /* CsrUint8 primitive->scanResults[i1].ssid.ssid[32] */
-            bufferSize += 1;                                                    /* CsrUint8 primitive->scanResults[i1].ssid.length */
-            bufferSize += 6;                                                    /* CsrUint8 primitive->scanResults[i1].bssid.a[6] */
+            bufferSize += 32;                                                   /* u8 primitive->scanResults[i1].ssid.ssid[32] */
+            bufferSize += 1;                                                    /* u8 primitive->scanResults[i1].ssid.length */
+            bufferSize += 6;                                                    /* u8 primitive->scanResults[i1].bssid.a[6] */
             bufferSize += 2;                                                    /* CsrInt16 primitive->scanResults[i1].rssi */
             bufferSize += 2;                                                    /* CsrInt16 primitive->scanResults[i1].snr */
             bufferSize += 1;                                                    /* CsrWifiSmeRadioIF primitive->scanResults[i1].ifIndex */
             bufferSize += 2;                                                    /* CsrUint16 primitive->scanResults[i1].beaconPeriodTu */
-            bufferSize += 8;                                                    /* CsrUint8 primitive->scanResults[i1].timeStamp.data[8] */
-            bufferSize += 8;                                                    /* CsrUint8 primitive->scanResults[i1].localTime.data[8] */
+            bufferSize += 8;                                                    /* u8 primitive->scanResults[i1].timeStamp.data[8] */
+            bufferSize += 8;                                                    /* u8 primitive->scanResults[i1].localTime.data[8] */
             bufferSize += 2;                                                    /* CsrUint16 primitive->scanResults[i1].channelFrequency */
             bufferSize += 2;                                                    /* CsrUint16 primitive->scanResults[i1].capabilityInformation */
-            bufferSize += 1;                                                    /* CsrUint8 primitive->scanResults[i1].channelNumber */
+            bufferSize += 1;                                                    /* u8 primitive->scanResults[i1].channelNumber */
             bufferSize += 1;                                                    /* CsrWifiSmeBasicUsability primitive->scanResults[i1].usability */
             bufferSize += 1;                                                    /* CsrWifiSmeBssType primitive->scanResults[i1].bssType */
             bufferSize += 2;                                                    /* CsrUint16 primitive->scanResults[i1].informationElementsLength */
-            bufferSize += primitive->scanResults[i1].informationElementsLength; /* CsrUint8 primitive->scanResults[i1].informationElements */
+            bufferSize += primitive->scanResults[i1].informationElementsLength; /* u8 primitive->scanResults[i1].informationElements */
             bufferSize += 1;                                                    /* CsrWifiSmeP2pRole primitive->scanResults[i1].p2pDeviceRole */
             switch (primitive->scanResults[i1].p2pDeviceRole)
             {
                 case CSR_WIFI_SME_P2P_ROLE_CLI:
-                    bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.reservedCli.empty */
+                    bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.reservedCli.empty */
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_GO:
                     bufferSize += 1; /* CsrWifiSmeP2pGroupCapabilityMask primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability */
-                    bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
-                    bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount */
+                    bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
+                    bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount */
                     {
                         CsrUint16 i4;
                         for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
                         {
-                            bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
-                            bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a[6] */
+                            bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
+                            bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a[6] */
                             bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods */
                             bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap */
-                            bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
-                            bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
+                            bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
+                            bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
                             {
                                 CsrUint16 i6;
                                 for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
                                 {
-                                    bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
+                                    bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
                                 }
                             }
-                            bufferSize += 32;        /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName[32] */
-                            bufferSize += 1;         /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength */
+                            bufferSize += 32;        /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName[32] */
+                            bufferSize += 1;         /* u8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength */
                         }
                     }
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_NONE:
-                    bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.reservedNone.empty */
+                    bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.reservedNone.empty */
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
-                    bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a[6] */
+                    bufferSize += 6; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a[6] */
                     bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods */
                     bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap */
-                    bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
-                    bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
+                    bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
+                    bufferSize += 1; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
                     {
                         CsrUint16 i4;
                         for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
                         {
-                            bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
+                            bufferSize += 8; /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
                         }
                     }
-                    bufferSize += 32;        /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName[32] */
-                    bufferSize += 1;         /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength */
+                    bufferSize += 32;        /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName[32] */
+                    bufferSize += 1;         /* u8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength */
                     break;
                 default:
                     break;
@@ -4891,7 +4891,7 @@ CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *)msg;
     *len = 0;
@@ -4903,34 +4903,34 @@ CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
         for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
         {
             CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].ssid.ssid, ((CsrUint16) (32)));
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].ssid.length);
+            CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].ssid.length);
             CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].bssid.a, ((CsrUint16) (6)));
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].rssi);
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].snr);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].ifIndex);
+            CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].ifIndex);
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].beaconPeriodTu);
             CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].timeStamp.data, ((CsrUint16) (8)));
             CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].localTime.data, ((CsrUint16) (8)));
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].channelFrequency);
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].capabilityInformation);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].channelNumber);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].usability);
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].bssType);
+            CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].channelNumber);
+            CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].usability);
+            CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].bssType);
             CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].informationElementsLength);
             if (primitive->scanResults[i1].informationElementsLength)
             {
                 CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].informationElements, ((CsrUint16) (primitive->scanResults[i1].informationElementsLength)));
             }
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].p2pDeviceRole);
+            CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].p2pDeviceRole);
             switch (primitive->scanResults[i1].p2pDeviceRole)
             {
                 case CSR_WIFI_SME_P2P_ROLE_CLI:
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.reservedCli.empty);
+                    CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.reservedCli.empty);
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_GO:
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability);
+                    CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability);
                     CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, ((CsrUint16) (6)));
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount);
+                    CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount);
                     {
                         CsrUint16 i4;
                         for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
@@ -4938,9 +4938,9 @@ CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
                             CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((CsrUint16) (6)));
                             CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((CsrUint16) (6)));
                             CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
-                            CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
+                            CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
                             CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
-                            CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
+                            CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
                             {
                                 CsrUint16 i6;
                                 for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
@@ -4949,19 +4949,19 @@ CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
                                 }
                             }
                             CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((CsrUint16) (32)));
-                            CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
+                            CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
                         }
                     }
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_NONE:
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.reservedNone.empty);
+                    CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.reservedNone.empty);
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
                     CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, ((CsrUint16) (6)));
                     CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods);
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap);
+                    CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap);
                     CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
+                    CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
                     {
                         CsrUint16 i4;
                         for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
@@ -4970,7 +4970,7 @@ CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
                         }
                     }
                     CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, ((CsrUint16) (32)));
-                    CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength);
+                    CsrUint8Ser(ptr, len, (u8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength);
                     break;
                 default:
                     break;
@@ -4981,7 +4981,7 @@ CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeScanResultsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultsGetCfm));
     CsrSize offset;
@@ -5000,39 +5000,39 @@ void* CsrWifiSmeScanResultsGetCfmDes(CsrUint8 *buffer, CsrSize length)
         for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
         {
             CsrMemCpyDes(primitive->scanResults[i1].ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
-            CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].ssid.length, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->scanResults[i1].ssid.length, buffer, &offset);
             CsrMemCpyDes(primitive->scanResults[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
             CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].rssi, buffer, &offset);
             CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].snr, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].ifIndex, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->scanResults[i1].ifIndex, buffer, &offset);
             CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].beaconPeriodTu, buffer, &offset);
             CsrMemCpyDes(primitive->scanResults[i1].timeStamp.data, buffer, &offset, ((CsrUint16) (8)));
             CsrMemCpyDes(primitive->scanResults[i1].localTime.data, buffer, &offset, ((CsrUint16) (8)));
             CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].channelFrequency, buffer, &offset);
             CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].capabilityInformation, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].channelNumber, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].usability, buffer, &offset);
-            CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].bssType, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->scanResults[i1].channelNumber, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->scanResults[i1].usability, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->scanResults[i1].bssType, buffer, &offset);
             CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].informationElementsLength, buffer, &offset);
             if (primitive->scanResults[i1].informationElementsLength)
             {
-                primitive->scanResults[i1].informationElements = (CsrUint8 *)CsrPmemAlloc(primitive->scanResults[i1].informationElementsLength);
+                primitive->scanResults[i1].informationElements = (u8 *)CsrPmemAlloc(primitive->scanResults[i1].informationElementsLength);
                 CsrMemCpyDes(primitive->scanResults[i1].informationElements, buffer, &offset, ((CsrUint16) (primitive->scanResults[i1].informationElementsLength)));
             }
             else
             {
                 primitive->scanResults[i1].informationElements = NULL;
             }
-            CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].p2pDeviceRole, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->scanResults[i1].p2pDeviceRole, buffer, &offset);
             switch (primitive->scanResults[i1].p2pDeviceRole)
             {
                 case CSR_WIFI_SME_P2P_ROLE_CLI:
-                    CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.reservedCli.empty, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.reservedCli.empty, buffer, &offset);
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_GO:
-                    CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability, buffer, &offset);
                     CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
-                    CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
                     primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo = NULL;
                     if (primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount)
                     {
@@ -5045,9 +5045,9 @@ void* CsrWifiSmeScanResultsGetCfmDes(CsrUint8 *buffer, CsrSize length)
                             CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((CsrUint16) (6)));
                             CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
                             CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
-                            CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, buffer, &offset);
+                            CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, buffer, &offset);
                             CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
-                            CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
+                            CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
                             primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = NULL;
                             if (primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount)
                             {
@@ -5061,19 +5061,19 @@ void* CsrWifiSmeScanResultsGetCfmDes(CsrUint8 *buffer, CsrSize length)
                                 }
                             }
                             CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
-                            CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
+                            CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
                         }
                     }
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_NONE:
-                    CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.reservedNone.empty, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.reservedNone.empty, buffer, &offset);
                     break;
                 case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
                     CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
                     CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
-                    CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
                     CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
-                    CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
                     primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType = NULL;
                     if (primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount)
                     {
@@ -5087,7 +5087,7 @@ void* CsrWifiSmeScanResultsGetCfmDes(CsrUint8 *buffer, CsrSize length)
                         }
                     }
                     CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
-                    CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
+                    CsrUint8Des((u8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
                     break;
                 default:
                     break;
@@ -5139,8 +5139,8 @@ CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
     bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
-    bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
+    bufferSize += 1; /* u8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
+    bufferSize += 1; /* u8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
     bufferSize += 1; /* CsrWifiSmeWmmModeMask primitive->smeConfig.wmmModeMask */
     bufferSize += 1; /* CsrWifiSmeRadioIF primitive->smeConfig.ifIndex */
     bufferSize += 1; /* CsrBool primitive->smeConfig.allowUnicastUseGroupCipher */
@@ -5149,24 +5149,24 @@ CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeSmeStaConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeSmeStaConfigGetCfm *primitive = (CsrWifiSmeSmeStaConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.wmmModeMask);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.ifIndex);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.allowUnicastUseGroupCipher);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.enableOpportunisticKeyCaching);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.wmmModeMask);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.ifIndex);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.allowUnicastUseGroupCipher);
+    CsrUint8Ser(ptr, len, (u8) primitive->smeConfig.enableOpportunisticKeyCaching);
     return(ptr);
 }
 
 
-void* CsrWifiSmeSmeStaConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeSmeStaConfigGetCfm *primitive = (CsrWifiSmeSmeStaConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigGetCfm));
     CsrSize offset;
@@ -5175,12 +5175,12 @@ void* CsrWifiSmeSmeStaConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.ifIndex, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.allowUnicastUseGroupCipher, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->smeConfig.enableOpportunisticKeyCaching, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.ifIndex, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.allowUnicastUseGroupCipher, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->smeConfig.enableOpportunisticKeyCaching, buffer, &offset);
 
     return primitive;
 }
@@ -5197,7 +5197,7 @@ CsrSize CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeSmeStaConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeSmeStaConfigSetCfm *primitive = (CsrWifiSmeSmeStaConfigSetCfm *)msg;
     *len = 0;
@@ -5208,7 +5208,7 @@ CsrUint8* CsrWifiSmeSmeStaConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg
 }
 
 
-void* CsrWifiSmeSmeStaConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeSmeStaConfigSetCfm *primitive = (CsrWifiSmeSmeStaConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigSetCfm));
     CsrSize offset;
@@ -5232,14 +5232,14 @@ CsrSize CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg)
         CsrUint16 i1;
         for (i1 = 0; i1 < 2; i1++)
         {
-            bufferSize += 6; /* CsrUint8 primitive->stationMacAddress[i1].a[6] */
+            bufferSize += 6; /* u8 primitive->stationMacAddress[i1].a[6] */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeStationMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeStationMacAddressGetCfm *primitive = (CsrWifiSmeStationMacAddressGetCfm *)msg;
     *len = 0;
@@ -5256,7 +5256,7 @@ CsrUint8* CsrWifiSmeStationMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void
 }
 
 
-void* CsrWifiSmeStationMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeStationMacAddressGetCfm *primitive = (CsrWifiSmeStationMacAddressGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeStationMacAddressGetCfm));
     CsrSize offset;
@@ -5286,19 +5286,19 @@ CsrSize CsrWifiSmeTspecIndSizeof(void *msg)
     bufferSize += 4;                      /* CsrUint32 primitive->transactionId */
     bufferSize += 1;                      /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
     bufferSize += 2;                      /* CsrUint16 primitive->tspecLength */
-    bufferSize += primitive->tspecLength; /* CsrUint8 primitive->tspec */
+    bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeTspecIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeTspecIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->tspecResultCode);
+    CsrUint8Ser(ptr, len, (u8) primitive->tspecResultCode);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
     if (primitive->tspecLength)
     {
@@ -5308,7 +5308,7 @@ CsrUint8* CsrWifiSmeTspecIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeTspecIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeTspecIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecInd));
     CsrSize offset;
@@ -5317,11 +5317,11 @@ void* CsrWifiSmeTspecIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->tspecResultCode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->tspecResultCode, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
     if (primitive->tspecLength)
     {
-        primitive->tspec = (CsrUint8 *)CsrPmemAlloc(primitive->tspecLength);
+        primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
         CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
     }
     else
@@ -5352,12 +5352,12 @@ CsrSize CsrWifiSmeTspecCfmSizeof(void *msg)
     bufferSize += 4;                      /* CsrUint32 primitive->transactionId */
     bufferSize += 1;                      /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
     bufferSize += 2;                      /* CsrUint16 primitive->tspecLength */
-    bufferSize += primitive->tspecLength; /* CsrUint8 primitive->tspec */
+    bufferSize += primitive->tspecLength; /* u8 primitive->tspec */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeTspecCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeTspecCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *)msg;
     *len = 0;
@@ -5365,7 +5365,7 @@ CsrUint8* CsrWifiSmeTspecCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
     CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->tspecResultCode);
+    CsrUint8Ser(ptr, len, (u8) primitive->tspecResultCode);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
     if (primitive->tspecLength)
     {
@@ -5375,7 +5375,7 @@ CsrUint8* CsrWifiSmeTspecCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeTspecCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeTspecCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecCfm));
     CsrSize offset;
@@ -5385,11 +5385,11 @@ void* CsrWifiSmeTspecCfmDes(CsrUint8 *buffer, CsrSize length)
     CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
     CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->tspecResultCode, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->tspecResultCode, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
     if (primitive->tspecLength)
     {
-        primitive->tspec = (CsrUint8 *)CsrPmemAlloc(primitive->tspecLength);
+        primitive->tspec = (u8 *)CsrPmemAlloc(primitive->tspecLength);
         CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
     }
     else
@@ -5429,7 +5429,7 @@ CsrSize CsrWifiSmeVersionsGetCfmSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeVersionsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *)msg;
     *len = 0;
@@ -5448,7 +5448,7 @@ CsrUint8* CsrWifiSmeVersionsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeVersionsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeVersionsGetCfm));
     CsrSize offset;
@@ -5486,39 +5486,39 @@ CsrSize CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 39) */
     bufferSize += 2; /* CsrResult primitive->status */
-    bufferSize += 1; /* CsrUint8 primitive->cloakedSsids.cloakedSsidsCount */
+    bufferSize += 1; /* u8 primitive->cloakedSsids.cloakedSsidsCount */
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
-            bufferSize += 32; /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
-            bufferSize += 1;  /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].length */
+            bufferSize += 32; /* u8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
+            bufferSize += 1;  /* u8 primitive->cloakedSsids.cloakedSsids[i2].length */
         }
     }
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeCloakedSsidsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsidsCount);
+    CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsidsCount);
     {
         CsrUint16 i2;
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
             CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((CsrUint16) (32)));
-            CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsids[i2].length);
+            CsrUint8Ser(ptr, len, (u8) primitive->cloakedSsids.cloakedSsids[i2].length);
         }
     }
     return(ptr);
 }
 
 
-void* CsrWifiSmeCloakedSsidsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsGetCfm));
     CsrSize offset;
@@ -5526,7 +5526,7 @@ void* CsrWifiSmeCloakedSsidsGetCfmDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
     primitive->cloakedSsids.cloakedSsids = NULL;
     if (primitive->cloakedSsids.cloakedSsidsCount)
     {
@@ -5537,7 +5537,7 @@ void* CsrWifiSmeCloakedSsidsGetCfmDes(CsrUint8 *buffer, CsrSize length)
         for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
         {
             CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((CsrUint16) (32)));
-            CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
+            CsrUint8Des((u8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
         }
     }
 
@@ -5558,12 +5558,12 @@ CsrSize CsrWifiSmeWifiOnIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
-    bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+    bufferSize += 6; /* u8 primitive->address.a[6] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeWifiOnInd *primitive = (CsrWifiSmeWifiOnInd *)msg;
     *len = 0;
@@ -5573,7 +5573,7 @@ CsrUint8* CsrWifiSmeWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeWifiOnIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeWifiOnIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeWifiOnInd *primitive = (CsrWifiSmeWifiOnInd *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnInd));
     CsrSize offset;
@@ -5593,28 +5593,28 @@ CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg)
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
     bufferSize += 2; /* CsrResult primitive->status */
     bufferSize += 1; /* CsrWifiSme80211dTrustLevel primitive->deviceConfig.trustLevel */
-    bufferSize += 2; /* CsrUint8 primitive->deviceConfig.countryCode[2] */
+    bufferSize += 2; /* u8 primitive->deviceConfig.countryCode[2] */
     bufferSize += 1; /* CsrWifiSmeFirmwareDriverInterface primitive->deviceConfig.firmwareDriverInterface */
     bufferSize += 1; /* CsrBool primitive->deviceConfig.enableStrictDraftN */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeSmeCommonConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeSmeCommonConfigGetCfm *primitive = (CsrWifiSmeSmeCommonConfigGetCfm *)msg;
     *len = 0;
     CsrUint16Ser(ptr, len, primitive->common.type);
     CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.trustLevel);
+    CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.trustLevel);
     CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((CsrUint16) (2)));
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.firmwareDriverInterface);
-    CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.enableStrictDraftN);
+    CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.firmwareDriverInterface);
+    CsrUint8Ser(ptr, len, (u8) primitive->deviceConfig.enableStrictDraftN);
     return(ptr);
 }
 
 
-void* CsrWifiSmeSmeCommonConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeSmeCommonConfigGetCfm *primitive = (CsrWifiSmeSmeCommonConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigGetCfm));
     CsrSize offset;
@@ -5622,10 +5622,10 @@ void* CsrWifiSmeSmeCommonConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
 
     CsrUint16Des(&primitive->common.type, buffer, &offset);
     CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
     CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((CsrUint16) (2)));
-    CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
-    CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
+    CsrUint8Des((u8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
 
     return primitive;
 }
@@ -5638,12 +5638,12 @@ 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; /* CsrUint8 primitive->capBitmap[2] */
+    bufferSize += 2; /* u8 primitive->capBitmap[2] */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeInterfaceCapabilityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeInterfaceCapabilityGetCfm *primitive = (CsrWifiSmeInterfaceCapabilityGetCfm *)msg;
     *len = 0;
@@ -5655,7 +5655,7 @@ CsrUint8* CsrWifiSmeInterfaceCapabilityGetCfmSer(CsrUint8 *ptr, CsrSize *len, vo
 }
 
 
-void* CsrWifiSmeInterfaceCapabilityGetCfmDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeInterfaceCapabilityGetCfm *primitive = (CsrWifiSmeInterfaceCapabilityGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeInterfaceCapabilityGetCfm));
     CsrSize offset;
@@ -5681,7 +5681,7 @@ CsrSize CsrWifiSmeErrorIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeErrorIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *)msg;
     *len = 0;
@@ -5691,7 +5691,7 @@ CsrUint8* CsrWifiSmeErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeErrorIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeErrorIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *) CsrPmemAlloc(sizeof(CsrWifiSmeErrorInd));
     CsrSize offset;
@@ -5723,7 +5723,7 @@ CsrSize CsrWifiSmeInfoIndSizeof(void *msg)
 }
 
 
-CsrUint8* CsrWifiSmeInfoIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeInfoIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *)msg;
     *len = 0;
@@ -5733,7 +5733,7 @@ CsrUint8* CsrWifiSmeInfoIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeInfoIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeInfoIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *) CsrPmemAlloc(sizeof(CsrWifiSmeInfoInd));
     CsrSize offset;
@@ -5761,12 +5761,12 @@ CsrSize CsrWifiSmeCoreDumpIndSizeof(void *msg)
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
     bufferSize += 4;                     /* CsrUint32 primitive->dataLength */
-    bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+    bufferSize += primitive->dataLength; /* u8 primitive->data */
     return bufferSize;
 }
 
 
-CsrUint8* CsrWifiSmeCoreDumpIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, CsrSize *len, void *msg)
 {
     CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *)msg;
     *len = 0;
@@ -5780,7 +5780,7 @@ CsrUint8* CsrWifiSmeCoreDumpIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
 }
 
 
-void* CsrWifiSmeCoreDumpIndDes(CsrUint8 *buffer, CsrSize length)
+void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, CsrSize length)
 {
     CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *) CsrPmemAlloc(sizeof(CsrWifiSmeCoreDumpInd));
     CsrSize offset;
@@ -5790,7 +5790,7 @@ void* CsrWifiSmeCoreDumpIndDes(CsrUint8 *buffer, CsrSize length)
     CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
     if (primitive->dataLength)
     {
-        primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+        primitive->data = (u8 *)CsrPmemAlloc(primitive->dataLength);
         CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
     }
     else
diff --git a/drivers/staging/csr/csr_wifi_sme_serialize.h b/drivers/staging/csr/csr_wifi_sme_serialize.h
index 0080bf43a6c..700d04955c6 100644
--- a/drivers/staging/csr/csr_wifi_sme_serialize.h
+++ b/drivers/staging/csr/csr_wifi_sme_serialize.h
@@ -35,13 +35,13 @@ extern void CsrWifiSmePfree(void *ptr);
 #define CsrWifiSmeAdhocConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeAdhocConfigGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeAdhocConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAdhocConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeAdhocConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeAdhocConfigSetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeBlacklistReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeBlacklistReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeBlacklistReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeBlacklistReqSizeof(void *msg);
 extern void CsrWifiSmeBlacklistReqSerFree(void *msg);
 
@@ -50,8 +50,8 @@ extern void CsrWifiSmeBlacklistReqSerFree(void *msg);
 #define CsrWifiSmeCalibrationDataGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeCalibrationDataGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeCalibrationDataSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCalibrationDataSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCalibrationDataSetReqSizeof(void *msg);
 extern void CsrWifiSmeCalibrationDataSetReqSerFree(void *msg);
 
@@ -60,8 +60,8 @@ extern void CsrWifiSmeCalibrationDataSetReqSerFree(void *msg);
 #define CsrWifiSmeCcxConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeCcxConfigGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeCcxConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCcxConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeCcxConfigSetReqSerFree CsrWifiSmePfree
 
@@ -70,8 +70,8 @@ extern CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeCoexConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeCoexConfigGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeCoexConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoexConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeCoexConfigSetReqSerFree CsrWifiSmePfree
 
@@ -80,8 +80,8 @@ extern CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeCoexInfoGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeCoexInfoGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeConnectReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeConnectReqSizeof(void *msg);
 extern void CsrWifiSmeConnectReqSerFree(void *msg);
 
@@ -120,13 +120,13 @@ extern void CsrWifiSmeConnectReqSerFree(void *msg);
 #define CsrWifiSmeHostConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeHostConfigGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeHostConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeHostConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeHostConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeHostConfigSetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeKeyReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeKeyReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeKeyReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeKeyReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeKeyReqSizeof(void *msg);
 #define CsrWifiSmeKeyReqSerFree CsrWifiSmePfree
 
@@ -140,33 +140,33 @@ extern CsrSize CsrWifiSmeKeyReqSizeof(void *msg);
 #define CsrWifiSmeMibConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeMibConfigGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeMibConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMibConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeMibConfigSetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeMibGetNextReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetNextReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMibGetNextReqSizeof(void *msg);
 extern void CsrWifiSmeMibGetNextReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeMibGetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibGetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMibGetReqSizeof(void *msg);
 extern void CsrWifiSmeMibGetReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeMibSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMibSetReqSizeof(void *msg);
 extern void CsrWifiSmeMibSetReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeMulticastAddressReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMulticastAddressReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMulticastAddressReqSizeof(void *msg);
 extern void CsrWifiSmeMulticastAddressReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmePacketFilterSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePacketFilterSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmePacketFilterSetReqSizeof(void *msg);
 extern void CsrWifiSmePacketFilterSetReqSerFree(void *msg);
 
@@ -175,8 +175,8 @@ extern void CsrWifiSmePacketFilterSetReqSerFree(void *msg);
 #define CsrWifiSmePermanentMacAddressGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmePermanentMacAddressGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmePmkidReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePmkidReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePmkidReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePmkidReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmePmkidReqSizeof(void *msg);
 extern void CsrWifiSmePmkidReqSerFree(void *msg);
 
@@ -185,8 +185,8 @@ extern void CsrWifiSmePmkidReqSerFree(void *msg);
 #define CsrWifiSmePowerConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmePowerConfigGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmePowerConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePowerConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg);
 #define CsrWifiSmePowerConfigSetReqSerFree CsrWifiSmePfree
 
@@ -200,8 +200,8 @@ extern CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeRoamingConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeRoamingConfigGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeRoamingConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamingConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeRoamingConfigSetReqSerFree CsrWifiSmePfree
 
@@ -210,13 +210,13 @@ extern CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeScanConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeScanConfigGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeScanConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeScanConfigSetReqSizeof(void *msg);
 extern void CsrWifiSmeScanConfigSetReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeScanFullReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanFullReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeScanFullReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanFullReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeScanFullReqSizeof(void *msg);
 extern void CsrWifiSmeScanFullReqSerFree(void *msg);
 
@@ -235,8 +235,8 @@ extern void CsrWifiSmeScanFullReqSerFree(void *msg);
 #define CsrWifiSmeSmeStaConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeSmeStaConfigGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeSmeStaConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeStaConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeSmeStaConfigSetReqSerFree CsrWifiSmePfree
 
@@ -245,8 +245,8 @@ extern CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeStationMacAddressGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeStationMacAddressGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeTspecReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeTspecReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeTspecReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeTspecReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeTspecReqSizeof(void *msg);
 extern void CsrWifiSmeTspecReqSerFree(void *msg);
 
@@ -255,8 +255,8 @@ extern void CsrWifiSmeTspecReqSerFree(void *msg);
 #define CsrWifiSmeVersionsGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeVersionsGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeWifiFlightmodeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWifiFlightmodeReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeWifiFlightmodeReqSizeof(void *msg);
 extern void CsrWifiSmeWifiFlightmodeReqSerFree(void *msg);
 
@@ -265,13 +265,13 @@ extern void CsrWifiSmeWifiFlightmodeReqSerFree(void *msg);
 #define CsrWifiSmeWifiOffReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeWifiOffReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWifiOnReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWifiOnReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeWifiOnReqSizeof(void *msg);
 extern void CsrWifiSmeWifiOnReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeCloakedSsidsSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCloakedSsidsSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg);
 extern void CsrWifiSmeCloakedSsidsSetReqSerFree(void *msg);
 
@@ -285,8 +285,8 @@ extern void CsrWifiSmeCloakedSsidsSetReqSerFree(void *msg);
 #define CsrWifiSmeSmeCommonConfigGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeSmeCommonConfigGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeSmeCommonConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeCommonConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeSmeCommonConfigSetReqSerFree CsrWifiSmePfree
 
@@ -295,13 +295,13 @@ extern CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg);
 #define CsrWifiSmeInterfaceCapabilityGetReqSizeof CsrWifiEventSizeof
 #define CsrWifiSmeInterfaceCapabilityGetReqSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeWpsConfigurationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWpsConfigurationReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeWpsConfigurationReqSizeof(void *msg);
 extern void CsrWifiSmeWpsConfigurationReqSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSetReqSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSetReqDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeSetReqSizeof(void *msg);
 extern void CsrWifiSmeSetReqSerFree(void *msg);
 
@@ -310,8 +310,8 @@ extern void CsrWifiSmeSetReqSerFree(void *msg);
 #define CsrWifiSmeActivateCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeActivateCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeAdhocConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAdhocConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeAdhocConfigGetCfmSerFree CsrWifiSmePfree
 
@@ -320,23 +320,23 @@ extern CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeAdhocConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeAdhocConfigSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeAssociationCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg);
 extern void CsrWifiSmeAssociationCompleteIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeAssociationStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeAssociationStartIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeAssociationStartIndSizeof(void *msg);
 #define CsrWifiSmeAssociationStartIndSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeBlacklistCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeBlacklistCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeBlacklistCfmSizeof(void *msg);
 extern void CsrWifiSmeBlacklistCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeCalibrationDataGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCalibrationDataGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg);
 extern void CsrWifiSmeCalibrationDataGetCfmSerFree(void *msg);
 
@@ -345,18 +345,18 @@ extern void CsrWifiSmeCalibrationDataGetCfmSerFree(void *msg);
 #define CsrWifiSmeCalibrationDataSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeCalibrationDataSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeCcxConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCcxConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCcxConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeCcxConfigGetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeCcxConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCcxConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCcxConfigSetCfmSizeof(void *msg);
 #define CsrWifiSmeCcxConfigSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeCoexConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoexConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeCoexConfigGetCfmSerFree CsrWifiSmePfree
 
@@ -365,33 +365,33 @@ extern CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeCoexConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeCoexConfigSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeCoexInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoexInfoGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCoexInfoGetCfmSizeof(void *msg);
 #define CsrWifiSmeCoexInfoGetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeConnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeConnectCfmSizeof(void *msg);
 #define CsrWifiSmeConnectCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeConnectionConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg);
 extern void CsrWifiSmeConnectionConfigGetCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeConnectionInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg);
 extern void CsrWifiSmeConnectionInfoGetCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeConnectionQualityIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionQualityIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeConnectionQualityIndSizeof(void *msg);
 #define CsrWifiSmeConnectionQualityIndSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeConnectionStatsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeConnectionStatsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg);
 #define CsrWifiSmeConnectionStatsGetCfmSerFree CsrWifiSmePfree
 
@@ -400,8 +400,8 @@ extern CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg);
 #define CsrWifiSmeDeactivateCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeDeactivateCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeDisconnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeDisconnectCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg);
 #define CsrWifiSmeDisconnectCfmSerFree CsrWifiSmePfree
 
@@ -410,38 +410,38 @@ extern CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg);
 #define CsrWifiSmeEventMaskSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeEventMaskSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeHostConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeHostConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeHostConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeHostConfigGetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeHostConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeHostConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeHostConfigSetCfmSizeof(void *msg);
 #define CsrWifiSmeHostConfigSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeIbssStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeIbssStationIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeIbssStationIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeIbssStationIndSizeof(void *msg);
 #define CsrWifiSmeIbssStationIndSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeKeyCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeKeyCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeKeyCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeKeyCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeKeyCfmSizeof(void *msg);
 #define CsrWifiSmeKeyCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeLinkQualityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeLinkQualityGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeLinkQualityGetCfmSizeof(void *msg);
 #define CsrWifiSmeLinkQualityGetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeMediaStatusIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg);
 extern void CsrWifiSmeMediaStatusIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeMibConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeMibConfigGetCfmSerFree CsrWifiSmePfree
 
@@ -450,13 +450,13 @@ extern CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeMibConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeMibConfigSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeMibGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMibGetCfmSizeof(void *msg);
 extern void CsrWifiSmeMibGetCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeMibGetNextCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMibGetNextCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMibGetNextCfmSizeof(void *msg);
 extern void CsrWifiSmeMibGetNextCfmSerFree(void *msg);
 
@@ -465,38 +465,38 @@ extern void CsrWifiSmeMibGetNextCfmSerFree(void *msg);
 #define CsrWifiSmeMibSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeMibSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMicFailureIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMicFailureIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMicFailureIndSizeof(void *msg);
 #define CsrWifiSmeMicFailureIndSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeMulticastAddressCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeMulticastAddressCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeMulticastAddressCfmSizeof(void *msg);
 extern void CsrWifiSmeMulticastAddressCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmePacketFilterSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePacketFilterSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmePacketFilterSetCfmSizeof(void *msg);
 #define CsrWifiSmePacketFilterSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmePermanentMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePermanentMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg);
 #define CsrWifiSmePermanentMacAddressGetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmePmkidCandidateListIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePmkidCandidateListIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg);
 extern void CsrWifiSmePmkidCandidateListIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmePmkidCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePmkidCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePmkidCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePmkidCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmePmkidCfmSizeof(void *msg);
 extern void CsrWifiSmePmkidCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmePowerConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmePowerConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmePowerConfigGetCfmSerFree CsrWifiSmePfree
 
@@ -505,33 +505,33 @@ extern CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmePowerConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmePowerConfigSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg);
 #define CsrWifiSmeRegulatoryDomainInfoGetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeRoamCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamCompleteIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeRoamCompleteIndSizeof(void *msg);
 #define CsrWifiSmeRoamCompleteIndSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeRoamStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamStartIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamStartIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeRoamStartIndSizeof(void *msg);
 #define CsrWifiSmeRoamStartIndSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeRoamingConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamingConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeRoamingConfigGetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeRoamingConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeRoamingConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg);
 #define CsrWifiSmeRoamingConfigSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeScanConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeScanConfigGetCfmSizeof(void *msg);
 extern void CsrWifiSmeScanConfigGetCfmSerFree(void *msg);
 
@@ -545,8 +545,8 @@ extern void CsrWifiSmeScanConfigGetCfmSerFree(void *msg);
 #define CsrWifiSmeScanFullCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeScanFullCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeScanResultIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanResultIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeScanResultIndSizeof(void *msg);
 extern void CsrWifiSmeScanResultIndSerFree(void *msg);
 
@@ -555,38 +555,38 @@ extern void CsrWifiSmeScanResultIndSerFree(void *msg);
 #define CsrWifiSmeScanResultsFlushCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeScanResultsFlushCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeScanResultsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg);
 extern void CsrWifiSmeScanResultsGetCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeSmeStaConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeStaConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeSmeStaConfigGetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeSmeStaConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeStaConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg);
 #define CsrWifiSmeSmeStaConfigSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeStationMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeStationMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg);
 #define CsrWifiSmeStationMacAddressGetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeTspecIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeTspecIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeTspecIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeTspecIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeTspecIndSizeof(void *msg);
 extern void CsrWifiSmeTspecIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeTspecCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeTspecCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeTspecCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeTspecCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeTspecCfmSizeof(void *msg);
 extern void CsrWifiSmeTspecCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeVersionsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeVersionsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeVersionsGetCfmSizeof(void *msg);
 extern void CsrWifiSmeVersionsGetCfmSerFree(void *msg);
 
@@ -615,18 +615,18 @@ extern void CsrWifiSmeVersionsGetCfmSerFree(void *msg);
 #define CsrWifiSmeCloakedSsidsSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeCloakedSsidsSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeCloakedSsidsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCloakedSsidsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg);
 extern void CsrWifiSmeCloakedSsidsGetCfmSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeWifiOnIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWifiOnIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeWifiOnIndSizeof(void *msg);
 #define CsrWifiSmeWifiOnIndSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeSmeCommonConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeSmeCommonConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeSmeCommonConfigGetCfmSerFree CsrWifiSmePfree
 
@@ -635,23 +635,23 @@ extern CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg);
 #define CsrWifiSmeSmeCommonConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
 #define CsrWifiSmeSmeCommonConfigSetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeInterfaceCapabilityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeInterfaceCapabilityGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg);
 #define CsrWifiSmeInterfaceCapabilityGetCfmSerFree CsrWifiSmePfree
 
-extern CsrUint8* CsrWifiSmeErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeErrorIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeErrorIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeErrorIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeErrorIndSizeof(void *msg);
 extern void CsrWifiSmeErrorIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeInfoIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeInfoIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeInfoIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeInfoIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeInfoIndSizeof(void *msg);
 extern void CsrWifiSmeInfoIndSerFree(void *msg);
 
-extern CsrUint8* CsrWifiSmeCoreDumpIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
-extern void* CsrWifiSmeCoreDumpIndDes(CsrUint8 *buffer, CsrSize len);
+extern u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, CsrSize len);
 extern CsrSize CsrWifiSmeCoreDumpIndSizeof(void *msg);
 extern void CsrWifiSmeCoreDumpIndSerFree(void *msg);
 
diff --git a/drivers/staging/csr/csr_wifi_vif_utils.h b/drivers/staging/csr/csr_wifi_vif_utils.h
index c534588c4c5..ee8b438bbba 100644
--- a/drivers/staging/csr/csr_wifi_vif_utils.h
+++ b/drivers/staging/csr/csr_wifi_vif_utils.h
@@ -24,7 +24,7 @@ extern "C" {
 /* MACROS *******************************************************************/
 
 /* Common macros for NME and SME to be used temporarily until SoftMAC changes are made */
-#define CSR_WIFI_NUM_INTERFACES        (CsrUint8)0x1
+#define CSR_WIFI_NUM_INTERFACES        (u8)0x1
 #define CSR_WIFI_INTERFACE_IN_USE      (CsrUint16)0x0
 
 /* This is used at places where interface Id isn't available*/
@@ -37,7 +37,7 @@ extern "C" {
 
 /* Extract the Interface Id from the event */
 #define CsrWifiVifUtilsGetVifTagFromEvent(msg) \
-    ((CsrUint16) * ((CsrUint16 *) ((CsrUint8 *) (msg) + sizeof(CsrWifiFsmEvent))))
+    ((CsrUint16) * ((CsrUint16 *) ((u8 *) (msg) + sizeof(CsrWifiFsmEvent))))
 
 /* The HPI Vif combines the type and the interface id */
 #define CsrWifiVifUtilsGetVifTagFromHipEvent(msg) \
@@ -58,16 +58,16 @@ extern "C" {
  *     First checks if the mode is supported capability bitmap of the interface.
  *     If this succeeds, then checks if running this mode on this interface is allowed.
  *
- * @param[in] CsrUint8 : interface capability bitmap
- * @param[in] CsrUint8* : pointer to the array of current interface modes
+ * @param[in] u8 : interface capability bitmap
+ * @param[in] u8* : pointer to the array of current interface modes
  * @param[in] CsrUint16 : interfaceTag
  * @param[in] CsrWifiInterfaceMode : mode
  *
  * @return
  *     CsrBool : returns true if the interface is allowed to operate in the mode otherwise false.
  */
-extern CsrBool CsrWifiVifUtilsCheckCompatibility(CsrUint8             interfaceCapability,
-                                                 CsrUint8            *currentInterfaceModes,
+extern CsrBool CsrWifiVifUtilsCheckCompatibility(u8             interfaceCapability,
+                                                 u8            *currentInterfaceModes,
                                                  CsrUint16            interfaceTag,
                                                  CsrWifiInterfaceMode mode);
 
diff --git a/drivers/staging/csr/netdev.c b/drivers/staging/csr/netdev.c
index 55149df5e34..e18395c1654 100644
--- a/drivers/staging/csr/netdev.c
+++ b/drivers/staging/csr/netdev.c
@@ -913,7 +913,7 @@ get_packet_priority(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr
     CSR_PRIORITY priority = CSR_CONTENTION;
     const int proto = ntohs(ehdr->h_proto);
 
-    CsrUint8 interfaceMode = interfacePriv->interfaceMode;
+    u8 interfaceMode = interfacePriv->interfaceMode;
 
     func_enter();
 
@@ -1088,7 +1088,7 @@ _identify_sme_ma_pkt_ind(unifi_priv_t *priv,
 {
     CSR_MA_PACKET_INDICATION *pkt_ind = (CSR_MA_PACKET_INDICATION*)&signal->u.MaPacketIndication;
     int r;
-    CsrUint8 i;
+    u8 i;
 
     unifi_trace(priv, UDBG5,
             "_identify_sme_ma_pkt_ind -->\n");
@@ -1141,7 +1141,7 @@ _identify_sme_ma_pkt_ind(unifi_priv_t *priv,
                             i,
                             pkt_ind->ReceptionStatus,
                             bulkdata->d[0].data_length,
-                            (CsrUint8*)bulkdata->d[0].os_data_ptr,
+                            (u8*)bulkdata->d[0].os_data_ptr,
                             NULL,
                             pkt_ind->Rssi,
                             pkt_ind->Snr,
@@ -1369,19 +1369,19 @@ int prepare_and_add_macheader(unifi_priv_t *priv, struct sk_buff *skb, struct sk
                               CSR_PRIORITY priority,
                               bulk_data_param_t *bulkdata,
                               CsrUint16 interfaceTag,
-                              const CsrUint8 *daddr,
-                              const CsrUint8 *saddr,
+                              const u8 *daddr,
+                              const u8 *saddr,
                               CsrBool protection)
 {
     CsrUint16 fc = 0;
-    CsrUint8 qc = 0;
-    CsrUint8 macHeaderLengthInBytes = MAC_HEADER_SIZE, *bufPtr = NULL;
+    u8 qc = 0;
+    u8 macHeaderLengthInBytes = MAC_HEADER_SIZE, *bufPtr = NULL;
     bulk_data_param_t data_ptrs;
     CsrResult csrResult;
     int headroom =0;
-    CsrUint8 direction = 0;
+    u8 direction = 0;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
-    CsrUint8 *addressOne;
+    u8 *addressOne;
     CsrBool bQosNull = false;
 
     if (skb == NULL) {
@@ -1478,14 +1478,14 @@ int prepare_and_add_macheader(unifi_priv_t *priv, struct sk_buff *skb, struct sk
         bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
         bulkdata->d[0].data_length = newSkb->len;
 
-        bufPtr = (CsrUint8*)data_ptrs.d[0].os_data_ptr;
+        bufPtr = (u8*)data_ptrs.d[0].os_data_ptr;
 
         /* The old skb will not be used again */
             kfree_skb(skb);
     } else {
 
         /* headroom has sufficient size, so will get proper pointer */
-        bufPtr = (CsrUint8*)skb_push(skb, macHeaderLengthInBytes);
+        bufPtr = (u8*)skb_push(skb, macHeaderLengthInBytes);
         bulkdata->d[0].os_data_ptr = skb->data;
         bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
         bulkdata->d[0].data_length = skb->len;
@@ -1753,7 +1753,7 @@ send_ma_pkt_request(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr
      * the Address 1 field of 802.11 Mac header here 4 is: (sizeof(framecontrol) + sizeof (durationID))
      * which is address 1 field
      */
-    memcpy(peerAddress.a, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+    memcpy(peerAddress.a, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
 
     unifi_trace(priv, UDBG5, "RA[0]=%x, RA[1]=%x, RA[2]=%x, RA[3]=%x, RA[4]=%x, RA[5]=%x\n",
                 peerAddress.a[0],peerAddress.a[1], peerAddress.a[2], peerAddress.a[3],
@@ -1792,7 +1792,7 @@ send_ma_pkt_request(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr
             req->TransmitRate = 0;
             req->HostTag = CSR_WIFI_EAPOL_M4_HOST_TAG;
             /* RA address matching with address 1 of Mac header */
-            memcpy(req->Ra.x, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+            memcpy(req->Ra.x, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
 
             spin_lock(&priv->m4_lock);
             /* Store the M4-PACKET.req for later */
@@ -1841,7 +1841,7 @@ send_ma_pkt_request(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr
         req->TransmitRate = (CSR_RATE) 0; /* rate selected by firmware */
         req->HostTag = 0xffffffff;        /* Ask for a new HostTag */
         /* RA address matching with address 1 of Mac header */
-        memcpy(req->Ra.x, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+        memcpy(req->Ra.x, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
 
         /* Store the M4-PACKET.req for later */
         spin_lock(&priv->wapi_lock);
@@ -2150,7 +2150,7 @@ unifi_restart_xmit(void *ospriv, unifi_TrafficQueue queue)
 
 
 static void
-indicate_rx_skb(unifi_priv_t *priv, CsrUint16 ifTag, CsrUint8* dst_a, CsrUint8* src_a, struct sk_buff *skb, CSR_SIGNAL *signal,
+indicate_rx_skb(unifi_priv_t *priv, CsrUint16 ifTag, u8* dst_a, u8* src_a, struct sk_buff *skb, CSR_SIGNAL *signal,
                 bulk_data_param_t *bulkdata)
 {
     int r, sr = 0;
@@ -2392,12 +2392,12 @@ unifi_rx(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
     const CSR_MA_PACKET_INDICATION *pkt_ind = &signal->u.MaPacketIndication;
     struct sk_buff *skb;
     CsrWifiRouterCtrlPortAction port_action;
-    CsrUint8 dataFrameType;
+    u8 dataFrameType;
     int proto;
     int queue;
 
-    CsrUint8 da[ETH_ALEN], sa[ETH_ALEN];
-    CsrUint8 toDs, fromDs, frameType, macHeaderLengthInBytes = MAC_HEADER_SIZE;
+    u8 da[ETH_ALEN], sa[ETH_ALEN];
+    u8 toDs, fromDs, frameType, macHeaderLengthInBytes = MAC_HEADER_SIZE;
     CsrUint16 frameControl;
     netInterface_priv_t *interfacePriv;
     struct ethhdr ehdr;
@@ -2738,15 +2738,15 @@ static void process_ma_packet_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_d
     struct sk_buff *skb;
     CsrUint16 frameControl;
     netInterface_priv_t *interfacePriv;
-    CsrUint8 da[ETH_ALEN], sa[ETH_ALEN];
-    CsrUint8 *bssid = NULL, *ba_addr = NULL;
-    CsrUint8 toDs, fromDs, frameType;
-    CsrUint8 i =0;
+    u8 da[ETH_ALEN], sa[ETH_ALEN];
+    u8 *bssid = NULL, *ba_addr = NULL;
+    u8 toDs, fromDs, frameType;
+    u8 i =0;
 
 #ifdef CSR_SUPPORT_SME
-    CsrUint8 dataFrameType = 0;
+    u8 dataFrameType = 0;
     CsrBool powerSaveChanged = FALSE;
-    CsrUint8 pmBit = 0;
+    u8 pmBit = 0;
     CsrWifiRouterCtrlStaInfo_t *srcStaInfo = NULL;
     CsrUint16 qosControl;
 
@@ -2812,7 +2812,7 @@ static void process_ma_packet_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_d
     }
     else
     {
-        bssid = (CsrUint8 *) (skb->data + 4 + 12 - (fromDs * 6) - (toDs * 12));
+        bssid = (u8 *) (skb->data + 4 + 12 - (fromDs * 6) - (toDs * 12));
     }
 
     pData = &bulkdata->d[0];
@@ -2827,7 +2827,7 @@ static void process_ma_packet_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_d
 
         if((frameControl & 0x00f0) == 0x00A0){
             /* This is a PS-POLL request */
-            CsrUint8 pmBit = (frameControl & 0x1000)?0x01:0x00;
+            u8 pmBit = (frameControl & 0x1000)?0x01:0x00;
             unifi_trace(priv, UDBG6, "%s: Received PS-POLL Frame\n", __FUNCTION__);
 
             uf_process_ps_poll(priv,sa,da,pmBit,interfaceTag);
@@ -2908,10 +2908,10 @@ static void process_ma_packet_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_d
 #endif
 
     if( ((frameControl & 0x00f0) >> 4) == QOS_DATA) {
-        CsrUint8 *qos_control_ptr = (CsrUint8*)bulkdata->d[0].os_data_ptr + (((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK))?30: 24);
+        u8 *qos_control_ptr = (u8*)bulkdata->d[0].os_data_ptr + (((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK))?30: 24);
         int tID = *qos_control_ptr & IEEE802_11_QC_TID_MASK; /* using ls octet of qos control */
         ba_session_rx_struct *ba_session;
-        CsrUint8 ba_session_idx = 0;
+        u8 ba_session_idx = 0;
         /* Get the BA originator address */
         if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
            interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO){
@@ -3622,12 +3622,12 @@ static void
     CsrUint32 offset;
     CsrUint32 length = bulkdata->d[0].data_length;
     CsrUint32 subframe_length, subframe_body_length, dot11_hdr_size;
-    CsrUint8 *ptr;
+    u8 *ptr;
     bulk_data_param_t subframe_bulkdata;
-    CsrUint8 *dot11_hdr_ptr = (CsrUint8*)bulkdata->d[0].os_data_ptr;
+    u8 *dot11_hdr_ptr = (u8*)bulkdata->d[0].os_data_ptr;
     CsrResult csrResult;
     CsrUint16 frameControl;
-    CsrUint8 *qos_control_ptr;
+    u8 *qos_control_ptr;
 
     frameControl = le16_to_cpu(*((CsrUint16*)dot11_hdr_ptr));
     qos_control_ptr = dot11_hdr_ptr + (((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK))?30: 24);
@@ -3657,20 +3657,20 @@ static void
             break;
         }
 
-        memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr, dot11_hdr_ptr, dot11_hdr_size);
+        memcpy((u8*)subframe_bulkdata.d[0].os_data_ptr, dot11_hdr_ptr, dot11_hdr_size);
 
 
         /* When to DS=0 and from DS=0, address 3 will already have BSSID so no need to re-program */
         if ((frameControl & IEEE802_11_FC_TO_DS_MASK) && !(frameControl & IEEE802_11_FC_FROM_DS_MASK)){
-                memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr + IEEE802_11_ADDR3_OFFSET, ((struct ethhdr*)ptr)->h_dest, ETH_ALEN);
+                memcpy((u8*)subframe_bulkdata.d[0].os_data_ptr + IEEE802_11_ADDR3_OFFSET, ((struct ethhdr*)ptr)->h_dest, ETH_ALEN);
         }
         else if (!(frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK)){
-                memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr + IEEE802_11_ADDR3_OFFSET,
+                memcpy((u8*)subframe_bulkdata.d[0].os_data_ptr + IEEE802_11_ADDR3_OFFSET,
                          ((struct ethhdr*)ptr)->h_source,
                            ETH_ALEN);
         }
 
-        memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr + dot11_hdr_size,
+        memcpy((u8*)subframe_bulkdata.d[0].os_data_ptr + dot11_hdr_size,
                 ptr + sizeof(struct ethhdr),
                              subframe_body_length);
         unifi_trace(priv, UDBG6, "%s: calling unifi_rx. length = %d subframe_length = %d\n", __FUNCTION__, length, subframe_length);
@@ -3845,7 +3845,7 @@ static void process_ba_frame(unifi_priv_t *priv,
 static void process_ba_complete(unifi_priv_t *priv, netInterface_priv_t *interfacePriv)
 {
     frame_desc_struct *frame_desc;
-    CsrUint8 i;
+    u8 i;
 
     for(i = 0; i < interfacePriv->ba_complete_index; i++) {
         frame_desc = &interfacePriv->ba_complete[i];
@@ -3867,13 +3867,13 @@ static void check_ba_frame_age_timeout( unifi_priv_t *priv,
 {
     CsrTime now;
     CsrTime age;
-    CsrUint8 i, j;
+    u8 i, j;
     CsrUint16 sn_temp;
 
     /* gap is started at 1 because we have buffered frames and
      * hence a minimum gap of 1 exists
      */
-    CsrUint8 gap=1;
+    u8 gap=1;
 
     now = CsrTimeGet(NULL);
 
@@ -3945,7 +3945,7 @@ static void process_ma_packet_error_ind(unifi_priv_t *priv, CSR_SIGNAL *signal,
     const CSR_MA_PACKET_ERROR_INDICATION *pkt_err_ind = &signal->u.MaPacketErrorIndication;
     netInterface_priv_t *interfacePriv;
     ba_session_rx_struct *ba_session;
-    CsrUint8 ba_session_idx = 0;
+    u8 ba_session_idx = 0;
     CSR_PRIORITY        UserPriority;
     CSR_SEQUENCE_NUMBER sn;
 
diff --git a/drivers/staging/csr/putest.c b/drivers/staging/csr/putest.c
index 22614e7e8f7..676c8f6bf6b 100644
--- a/drivers/staging/csr/putest.c
+++ b/drivers/staging/csr/putest.c
@@ -24,15 +24,15 @@
 int unifi_putest_cmd52_read(unifi_priv_t *priv, unsigned char *arg)
 {
     struct unifi_putest_cmd52 cmd52_params;
-    CsrUint8 *arg_pos;
+    u8 *arg_pos;
     unsigned int cmd_param_size;
     int r;
     CsrResult csrResult;
     unsigned char ret_buffer[32];
-    CsrUint8 *ret_buffer_pos;
-    CsrUint8 retries;
+    u8 *ret_buffer_pos;
+    u8 retries;
 
-    arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+    arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1);
     if (get_user(cmd_param_size, (int*)arg_pos)) {
         unifi_error(priv,
                     "unifi_putest_cmd52_read: Failed to get the argument\n");
@@ -77,7 +77,7 @@ int unifi_putest_cmd52_read(unifi_priv_t *priv, unsigned char *arg)
 
     /* Copy the info to the out buffer */
     *(unifi_putest_command_t*)ret_buffer = UNIFI_PUTEST_CMD52_READ;
-    ret_buffer_pos = (CsrUint8*)(((unifi_putest_command_t*)ret_buffer) + 1);
+    ret_buffer_pos = (u8*)(((unifi_putest_command_t*)ret_buffer) + 1);
     *(unsigned int*)ret_buffer_pos = sizeof(struct unifi_putest_cmd52);
     ret_buffer_pos += sizeof(unsigned int);
     memcpy(ret_buffer_pos, &cmd52_params, sizeof(struct unifi_putest_cmd52));
@@ -99,12 +99,12 @@ int unifi_putest_cmd52_read(unifi_priv_t *priv, unsigned char *arg)
 int unifi_putest_cmd52_write(unifi_priv_t *priv, unsigned char *arg)
 {
     struct unifi_putest_cmd52 cmd52_params;
-    CsrUint8 *arg_pos;
+    u8 *arg_pos;
     unsigned int cmd_param_size;
     CsrResult csrResult;
-    CsrUint8 retries;
+    u8 retries;
 
-    arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+    arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1);
     if (get_user(cmd_param_size, (int*)arg_pos)) {
         unifi_error(priv,
                     "unifi_putest_cmd52_write: Failed to get the argument\n");
@@ -152,14 +152,14 @@ int unifi_putest_cmd52_write(unifi_priv_t *priv, unsigned char *arg)
 int unifi_putest_gp_read16(unifi_priv_t *priv, unsigned char *arg)
 {
     struct unifi_putest_gp_rw16 gp_r16_params;
-    CsrUint8 *arg_pos;
+    u8 *arg_pos;
     unsigned int cmd_param_size;
     int r;
     CsrResult csrResult;
     unsigned char ret_buffer[32];
-    CsrUint8 *ret_buffer_pos;
+    u8 *ret_buffer_pos;
 
-    arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+    arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1);
     if (get_user(cmd_param_size, (int*)arg_pos)) {
         unifi_error(priv,
                     "unifi_putest_gp_read16: Failed to get the argument\n");
@@ -193,7 +193,7 @@ int unifi_putest_gp_read16(unifi_priv_t *priv, unsigned char *arg)
 
     /* Copy the info to the out buffer */
     *(unifi_putest_command_t*)ret_buffer = UNIFI_PUTEST_GP_READ16;
-    ret_buffer_pos = (CsrUint8*)(((unifi_putest_command_t*)ret_buffer) + 1);
+    ret_buffer_pos = (u8*)(((unifi_putest_command_t*)ret_buffer) + 1);
     *(unsigned int*)ret_buffer_pos = sizeof(struct unifi_putest_gp_rw16);
     ret_buffer_pos += sizeof(unsigned int);
     memcpy(ret_buffer_pos, &gp_r16_params, sizeof(struct unifi_putest_gp_rw16));
@@ -214,11 +214,11 @@ int unifi_putest_gp_read16(unifi_priv_t *priv, unsigned char *arg)
 int unifi_putest_gp_write16(unifi_priv_t *priv, unsigned char *arg)
 {
     struct unifi_putest_gp_rw16 gp_w16_params;
-    CsrUint8 *arg_pos;
+    u8 *arg_pos;
     unsigned int cmd_param_size;
     CsrResult csrResult;
 
-    arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+    arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1);
     if (get_user(cmd_param_size, (int*)arg_pos)) {
         unifi_error(priv,
                     "unifi_putest_gp_write16: Failed to get the argument\n");
@@ -629,12 +629,12 @@ int unifi_putest_coredump_prepare(unifi_priv_t *priv, unsigned char *arg)
 int unifi_putest_cmd52_block_read(unifi_priv_t *priv, unsigned char *arg)
 {
     struct unifi_putest_block_cmd52_r block_cmd52;
-    CsrUint8 *arg_pos;
+    u8 *arg_pos;
     unsigned int cmd_param_size;
     CsrResult r;
-    CsrUint8 *block_local_buffer;
+    u8 *block_local_buffer;
 
-    arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+    arg_pos = (u8*)(((unifi_putest_command_t*)arg) + 1);
     if (get_user(cmd_param_size, (int*)arg_pos)) {
         unifi_error(priv,
                     "cmd52r_block: Failed to get the argument\n");
diff --git a/drivers/staging/csr/sdio_mmc.c b/drivers/staging/csr/sdio_mmc.c
index 24be0872b0a..f95a57f0072 100644
--- a/drivers/staging/csr/sdio_mmc.c
+++ b/drivers/staging/csr/sdio_mmc.c
@@ -144,7 +144,7 @@ csr_io_rw_direct(struct mmc_card *card, int write, uint8_t fn,
 
 
 CsrResult
-CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data)
+CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, u8 *data)
 {
     struct sdio_func *func = (struct sdio_func *)function->priv;
     int err = 0;
@@ -162,7 +162,7 @@ CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data)
 } /* CsrSdioRead8() */
 
 CsrResult
-CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data)
+CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, u8 data)
 {
     struct sdio_func *func = (struct sdio_func *)function->priv;
     int err = 0;
@@ -234,7 +234,7 @@ CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data)
 
 
 CsrResult
-CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data)
+CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, u8 *data)
 {
     struct sdio_func *func = (struct sdio_func *)function->priv;
     int err = 0;
@@ -256,7 +256,7 @@ CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data)
 } /* CsrSdioF0Read8() */
 
 CsrResult
-CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data)
+CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, u8 data)
 {
     struct sdio_func *func = (struct sdio_func *)function->priv;
     int err = 0;
diff --git a/drivers/staging/csr/sme_mgt.c b/drivers/staging/csr/sme_mgt.c
index c27c0a73aa4..28295ef9b97 100644
--- a/drivers/staging/csr/sme_mgt.c
+++ b/drivers/staging/csr/sme_mgt.c
@@ -126,7 +126,7 @@ void CsrWifiSmeScanResultsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
     CsrWifiSmeScanResultsGetCfm* cfm = (CsrWifiSmeScanResultsGetCfm*)msg;
     int bytesRequired = cfm->scanResultsCount * sizeof(CsrWifiSmeScanResult);
     int i;
-    CsrUint8* current_buff;
+    u8* current_buff;
     CsrWifiSmeScanResult* scanCopy;
 
     if (priv == NULL) {
@@ -145,7 +145,7 @@ void CsrWifiSmeScanResultsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
     memcpy(scanCopy, cfm->scanResults, sizeof(CsrWifiSmeScanResult) * cfm->scanResultsCount);
 
     /* Take a Copy of the Info Elements AND update the scan result pointers */
-    current_buff = (CsrUint8*)&scanCopy[cfm->scanResultsCount];
+    current_buff = (u8*)&scanCopy[cfm->scanResultsCount];
     for (i = 0; i < cfm->scanResultsCount; ++i)
     {
         CsrWifiSmeScanResult *scan_result = &scanCopy[i];
diff --git a/drivers/staging/csr/sme_sys.c b/drivers/staging/csr/sme_sys.c
index 5f38f9dbb98..a84d99f7892 100644
--- a/drivers/staging/csr/sme_sys.c
+++ b/drivers/staging/csr/sme_sys.c
@@ -63,7 +63,7 @@ void send_auto_ma_packet_confirm(unifi_priv_t *priv,
     int client_id;
 
     CSR_SIGNAL unpacked_signal;
-    CsrUint8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
+    u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
     CsrUint16 packed_siglen;
 
 
@@ -111,7 +111,7 @@ void send_auto_ma_packet_confirm(unifi_priv_t *priv,
 
                 CsrWifiRouterCtrlHipIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,
                                             packed_siglen,
-                                            (CsrUint8 *)sigbuf,
+                                            (u8 *)sigbuf,
                                             0, NULL,
                                             0, NULL);
             }
@@ -406,7 +406,7 @@ uf_send_gratuitous_arp(unifi_priv_t *priv, CsrUint16 interfaceTag)
     struct sk_buff *skb, *newSkb = NULL;
     CsrInt8 protection;
     int r;
-    static const CsrUint8 arp_req[36] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00,
+    static const u8 arp_req[36] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00,
                                          0x08, 0x06, 0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01,
                                          0x00, 0x02, 0x5f, 0x20, 0x2f, 0x02,
                                          0xc0, 0xa8, 0x00, 0x02,
@@ -506,7 +506,7 @@ configure_data_port(unifi_priv_t *priv,
         const int queue,
         CsrUint16 interfaceTag)
 {
-    const CsrUint8 broadcast_mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    const u8 broadcast_mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
     unifi_port_config_t *port;
     netInterface_priv_t *interfacePriv;
     int i;
@@ -686,7 +686,7 @@ void CsrWifiRouterCtrlPortConfigureReqHandler(void* drvpriv, CsrWifiFsmEvent* ms
         case CSR_WIFI_ROUTER_CTRL_MODE_AP:
         case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
             {
-                CsrUint8 i;
+                u8 i;
                 CsrWifiRouterCtrlStaInfo_t *staRecord;
                 /* Ifscontrolled port is open means, The peer has been added to station record
                  * so that the protection corresponding to the peer is valid in this req
@@ -1212,7 +1212,7 @@ void CsrWifiRouterMaPacketSubscribeReqHandler(void* drvpriv, CsrWifiFsmEvent* ms
 {
     unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
     CsrWifiRouterMaPacketSubscribeReq* req = (CsrWifiRouterMaPacketSubscribeReq*)msg;
-    CsrUint8 i;
+    u8 i;
     CsrResult result;
 
     if (priv == NULL) {
@@ -1232,9 +1232,9 @@ void CsrWifiRouterMaPacketSubscribeReqHandler(void* drvpriv, CsrWifiFsmEvent* ms
             priv->sme_unidata_ind_filters[i].encapsulation = req->encapsulation;
             priv->sme_unidata_ind_filters[i].protocol = req->protocol;
 
-            priv->sme_unidata_ind_filters[i].oui[2] = (CsrUint8)  (req->oui        & 0xFF);
-            priv->sme_unidata_ind_filters[i].oui[1] = (CsrUint8) ((req->oui >>  8) & 0xFF);
-            priv->sme_unidata_ind_filters[i].oui[0] = (CsrUint8) ((req->oui >> 16) & 0xFF);
+            priv->sme_unidata_ind_filters[i].oui[2] = (u8)  (req->oui        & 0xFF);
+            priv->sme_unidata_ind_filters[i].oui[1] = (u8) ((req->oui >>  8) & 0xFF);
+            priv->sme_unidata_ind_filters[i].oui[0] = (u8) ((req->oui >> 16) & 0xFF);
 
             result = CSR_RESULT_SUCCESS;
             break;
@@ -1353,8 +1353,8 @@ void CsrWifiRouterCtrlTrafficClassificationReqHandler(void* drvpriv, CsrWifiFsmE
 
 static int
 _sys_packet_req(unifi_priv_t *priv, const CSR_SIGNAL *signal,
-        CsrUint8 subscriptionHandle,
-        CsrUint16 frameLength, CsrUint8 *frame,
+        u8 subscriptionHandle,
+        CsrUint16 frameLength, u8 *frame,
         int proto)
 {
     int r;
@@ -1502,7 +1502,7 @@ void CsrWifiRouterMaPacketReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
     CSR_SIGNAL signal;
     CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
     CsrWifiRouterCtrlPortAction controlPortaction;
-    CsrUint8 *daddr, *saddr;
+    u8 *daddr, *saddr;
     CsrUint16 interfaceTag = mareq->interfaceTag & 0x00ff;
     int queue;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
@@ -1640,7 +1640,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)
 {
-    CsrUint8 i,j;
+    u8 i,j;
     CsrWifiRouterCtrlStaInfo_t *staInfo=NULL;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
     unsigned long lock_flags;
@@ -1798,7 +1798,7 @@ void CsrWifiRouterCtrlModeSetReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
     {
         netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
 #ifdef CSR_WIFI_SPLIT_PATCH
-        CsrUint8 old_mode = interfacePriv->interfaceMode;
+        u8 old_mode = interfacePriv->interfaceMode;
 #endif
         unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlModeSetReqHandler: interfacePriv->interfaceMode = %d\n",
                 interfacePriv->interfaceMode);
@@ -1914,13 +1914,13 @@ void CsrWifiRouterMaPacketResHandler(void* drvpriv, CsrWifiFsmEvent* msg)
 /* delete the station record from the station record data base */
 static int peer_delete_record(unifi_priv_t *priv, CsrWifiRouterCtrlPeerDelReq *req)
 {
-    CsrUint8 j;
+    u8 j;
     CsrWifiRouterCtrlStaInfo_t *staInfo = NULL;
     unifi_port_config_t *controlledPort;
     unifi_port_config_t *unControlledPort;
     netInterface_priv_t *interfacePriv;
 
-    CsrUint8 ba_session_idx = 0;
+    u8 ba_session_idx = 0;
     ba_session_rx_struct *ba_session_rx = NULL;
     ba_session_tx_struct *ba_session_tx = NULL;
 
@@ -2100,7 +2100,7 @@ void CsrWifiRouterCtrlPeerDelReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
 /* Add the new station to the station record data base */
 static int peer_add_new_record(unifi_priv_t *priv,CsrWifiRouterCtrlPeerAddReq *req,CsrUint32 *handle)
 {
-    CsrUint8 i, powerModeTemp = 0;
+    u8 i, powerModeTemp = 0;
     CsrBool freeSlotFound = FALSE;
     CsrWifiRouterCtrlStaInfo_t *newRecord = NULL;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
@@ -2157,7 +2157,7 @@ static int peer_add_new_record(unifi_priv_t *priv,CsrWifiRouterCtrlPeerAddReq *r
             newRecord->assignedHandle = i;
 
              /* copy power save mode of all access catagory (Trigger/Delivery/both enabled/disabled) */
-            powerModeTemp = (CsrUint8) ((req->staInfo.powersaveMode >> 4) & 0xff);
+            powerModeTemp = (u8) ((req->staInfo.powersaveMode >> 4) & 0xff);
 
             if(!(req->staInfo.powersaveMode & 0x0001))
                 newRecord->powersaveMode[UNIFI_TRAFFIC_Q_BK]= CSR_WIFI_AC_LEGACY_POWER_SAVE;
@@ -2180,7 +2180,7 @@ static int peer_add_new_record(unifi_priv_t *priv,CsrWifiRouterCtrlPeerAddReq *r
                newRecord->powersaveMode[UNIFI_TRAFFIC_Q_VO]= ((powerModeTemp & 0xC0)>> 6);
 
             {
-                CsrUint8 k;
+                u8 k;
                 for(k=0; k< MAX_ACCESS_CATOGORY ;k++)
                     unifi_trace(priv, UDBG2, "peer_add_new_record: WMM : %d ,AC %d, powersaveMode %x \n",
                             req->staInfo.wmmOrQosEnabled,k,newRecord->powersaveMode[k]);
@@ -2191,7 +2191,7 @@ static int peer_add_new_record(unifi_priv_t *priv,CsrWifiRouterCtrlPeerAddReq *r
 
             /* Initialize the mgtFrames & data Pdu list */
             {
-                CsrUint8 j;
+                u8 j;
                 INIT_LIST_HEAD(&newRecord->mgtFrames);
                 for(j = 0; j < MAX_ACCESS_CATOGORY; j++) {
                     INIT_LIST_HEAD(&newRecord->dataPdu[j]);
@@ -2297,7 +2297,7 @@ static void check_inactivity_timer_expire_func(unsigned long data)
 {
     struct unifi_priv *priv;
     CsrWifiRouterCtrlStaInfo_t *sta_record = NULL;
-    CsrUint8 i = 0;
+    u8 i = 0;
     CsrTime now;
     CsrTime inactive_time;
     netInterface_priv_t *interfacePriv = (netInterface_priv_t *) data;
@@ -2411,7 +2411,7 @@ void uf_send_disconnected_ind_wq(struct work_struct *work)
     unifi_priv_t *priv;
     CsrUint16 interfaceTag;
     struct list_head send_cfm_list;
-    CsrUint8 j;
+    u8 j;
 
     func_enter();
 
@@ -2619,7 +2619,7 @@ CsrBool blockack_session_stop(unifi_priv_t *priv,
     netInterface_priv_t *interfacePriv;
     ba_session_rx_struct *ba_session_rx = NULL;
     ba_session_tx_struct *ba_session_tx = NULL;
-    CsrUint8 ba_session_idx = 0;
+    u8 ba_session_idx = 0;
     int i;
 
     if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
@@ -2743,7 +2743,7 @@ CsrBool blockack_session_start(unifi_priv_t *priv,
     netInterface_priv_t *interfacePriv;
     ba_session_rx_struct *ba_session_rx = NULL;
     ba_session_tx_struct *ba_session_tx = NULL;
-    CsrUint8 ba_session_idx = 0;
+    u8 ba_session_idx = 0;
 
 
     if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
@@ -3132,9 +3132,9 @@ void CsrWifiRouterCtrlWapiUnicastTxPktReqHandler(void* drvpriv, CsrWifiFsmEvent*
     CsrWifiRouterCtrlWapiUnicastTxPktReq *req   = (CsrWifiRouterCtrlWapiUnicastTxPktReq*) msg;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
     bulk_data_param_t bulkdata;
-    CsrUint8 macHeaderLengthInBytes = MAC_HEADER_SIZE;
+    u8 macHeaderLengthInBytes = MAC_HEADER_SIZE;
     /*KeyID, Reserved, PN, MIC*/
-    CsrUint8 appendedCryptoFields = 1 + 1 + 16 + 16;
+    u8 appendedCryptoFields = 1 + 1 + 16 + 16;
     CsrResult result;
     /* Retrieve the MA PACKET REQ fields from the Signal retained from send_ma_pkt_request() */
     CSR_MA_PACKET_REQUEST *storedSignalMAPktReq = &interfacePriv->wapi_unicast_ma_pkt_sig.u.MaPacketRequest;
diff --git a/drivers/staging/csr/sme_userspace.c b/drivers/staging/csr/sme_userspace.c
index d87a6e304ff..fc2506e4a95 100644
--- a/drivers/staging/csr/sme_userspace.c
+++ b/drivers/staging/csr/sme_userspace.c
@@ -119,7 +119,7 @@ void
 uf_sme_deinit(unifi_priv_t *priv)
 {
     int i,j;
-    CsrUint8 ba_session_idx;
+    u8 ba_session_idx;
     ba_session_rx_struct *ba_session_rx = NULL;
     ba_session_tx_struct *ba_session_tx = NULL;
     CsrWifiRouterCtrlStaInfo_t *staInfo = NULL;
diff --git a/drivers/staging/csr/sme_userspace.h b/drivers/staging/csr/sme_userspace.h
index 19f484f863b..e266efb0bcb 100644
--- a/drivers/staging/csr/sme_userspace.h
+++ b/drivers/staging/csr/sme_userspace.h
@@ -32,7 +32,7 @@ int uf_sme_queue_message(unifi_priv_t *priv, u8 *buffer, int length);
 #include "csr_wifi_sme_lib.h"
 
 void CsrWifiRouterTransportInit(unifi_priv_t *priv);
-void CsrWifiRouterTransportRecv(unifi_priv_t *priv, CsrUint8* buffer, CsrSize bufferLength);
+void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLength);
 void CsrWifiRouterTransportDeInit(unifi_priv_t *priv);
 
 #endif /* __LINUX_SME_USERSPACE_H__ */
diff --git a/drivers/staging/csr/sme_wext.c b/drivers/staging/csr/sme_wext.c
index cdc72dbd11c..64e2939efa0 100644
--- a/drivers/staging/csr/sme_wext.c
+++ b/drivers/staging/csr/sme_wext.c
@@ -457,10 +457,10 @@ static int decode_parameter_from_string(unifi_priv_t* priv, char **str_ptr,
                                         const char *token, int param_type,
                                         void  *dst, int param_max_len)
 {
-    CsrUint8 int_str[7] = "0";
+    u8 int_str[7] = "0";
     CsrUint32 param_str_len;
-    CsrUint8  *param_str_begin,*param_str_end;
-    CsrUint8  *orig_str = *str_ptr;
+    u8  *param_str_begin,*param_str_end;
+    u8  *orig_str = *str_ptr;
 
     if (!strncmp(*str_ptr, token, strlen(token))) {
         strsep(str_ptr, "=,");
@@ -616,7 +616,7 @@ static int store_ap_config_from_string( unifi_priv_t * priv,char *param_str)
         int i,j=0;
         CsrWifiNmeApAuthPers *pers =
                             ((CsrWifiNmeApAuthPers *)&(ap_config->credentials.nmeAuthType.authTypePersonal));
-        CsrUint8 *psk = pers->authPers_credentials.psk.psk;
+        u8 *psk = pers->authPers_credentials.psk.psk;
 
         unifi_trace(priv,UDBG2,"store_ap_config_from_string: security WPA2");
         if(ret) {
@@ -797,7 +797,7 @@ static int
 iwprivsconfwapi(struct net_device *dev, struct iw_request_info *info,
         union iwreq_data *wrqu, char *extra)
 {
-    CsrUint8 enable;
+    u8 enable;
     netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
     unifi_priv_t *priv = interfacePriv->privPtr;
     func_enter();
@@ -811,7 +811,7 @@ iwprivsconfwapi(struct net_device *dev, struct iw_request_info *info,
        return -EPERM;
     }
 
-    enable = *(CsrUint8*)(extra);
+    enable = *(u8*)(extra);
 
     if (enable) {
         priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
@@ -1255,7 +1255,7 @@ unifi_giwap(struct net_device *dev, struct iw_request_info *info,
     unifi_priv_t *priv = interfacePriv->privPtr;
     CsrWifiSmeConnectionInfo connectionInfo;
     int r = 0;
-    CsrUint8 *bssid;
+    u8 *bssid;
 
     func_enter();
 
diff --git a/drivers/staging/csr/ul_int.c b/drivers/staging/csr/ul_int.c
index 958b8a1a9eb..3135468ef36 100644
--- a/drivers/staging/csr/ul_int.c
+++ b/drivers/staging/csr/ul_int.c
@@ -213,7 +213,7 @@ ul_deregister_client(ul_client_t *ul_client)
  */
 void
 logging_handler(void *ospriv,
-                CsrUint8 *sigdata, CsrUint32 signal_len,
+                u8 *sigdata, CsrUint32 signal_len,
                 const bulk_data_param_t *bulkdata,
                 enum udi_log_direction direction)
 {
@@ -285,7 +285,7 @@ ul_log_config_ind(unifi_priv_t *priv, u8 *conf_param, int len)
     bulkdata.d[0].data_length = 0;
     bulkdata.d[1].data_length = 0;
 
-    sme_native_log_event(priv->sme_cli, conf_param, sizeof(CsrUint8),
+    sme_native_log_event(priv->sme_cli, conf_param, sizeof(u8),
                          &bulkdata, UDI_CONFIG_IND);
 
 #endif /* CSR_SUPPORT_SME */
@@ -324,7 +324,7 @@ free_bulkdata_buffers(unifi_priv_t *priv, bulk_data_param_t *bulkdata)
 } /* free_bulkdata_buffers */
 
 static int
-_align_bulk_data_buffers(unifi_priv_t *priv, CsrUint8 *signal,
+_align_bulk_data_buffers(unifi_priv_t *priv, u8 *signal,
                          bulk_data_param_t *bulkdata)
 {
     unsigned int i;
@@ -417,7 +417,7 @@ int
 ul_send_signal_unpacked(unifi_priv_t *priv, CSR_SIGNAL *sigptr,
                         bulk_data_param_t *bulkdata)
 {
-    CsrUint8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
+    u8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
     CsrUint16 packed_siglen;
     CsrResult csrResult;
     unsigned long lock_flags;
@@ -504,7 +504,7 @@ ul_send_signal_raw(unifi_priv_t *priv, unsigned char *sigptr, int siglen,
      * Make sure that the signal is updated with the bulk data
      * alignment for DMA.
      */
-    r = _align_bulk_data_buffers(priv, (CsrUint8*)sigptr, bulkdata);
+    r = _align_bulk_data_buffers(priv, (u8*)sigptr, bulkdata);
     if (r) {
         return r;
     }
diff --git a/drivers/staging/csr/unifi_clients.h b/drivers/staging/csr/unifi_clients.h
index 206b8cffd5b..ca105e56571 100644
--- a/drivers/staging/csr/unifi_clients.h
+++ b/drivers/staging/csr/unifi_clients.h
@@ -49,7 +49,7 @@ typedef void (*udi_event_t)(ul_client_t *client,
                             int dir);
 
 void logging_handler(void *ospriv,
-                     CsrUint8 *sigdata, CsrUint32 signal_len,
+                     u8 *sigdata, CsrUint32 signal_len,
                      const bulk_data_param_t *bulkdata,
                      enum udi_log_direction direction);
 
diff --git a/drivers/staging/csr/unifi_event.c b/drivers/staging/csr/unifi_event.c
index 8b5d4669e12..bbc1564bd2f 100644
--- a/drivers/staging/csr/unifi_event.c
+++ b/drivers/staging/csr/unifi_event.c
@@ -92,33 +92,33 @@ static void send_to_client(unifi_priv_t *priv, ul_client_t *client,
  * ---------------------------------------------------------------------------
  */
 static CsrBool check_routing_pkt_data_ind(unifi_priv_t *priv,
-        CsrUint8 *sigdata,
+        u8 *sigdata,
         const bulk_data_param_t* bulkdata,
         CsrBool *freeBulkData,
         netInterface_priv_t *interfacePriv)
 {
     CsrUint16  frmCtrl, receptionStatus, frmCtrlSubType;
-    CsrUint8 *macHdrLocation;
-    CsrUint8 interfaceTag;
+    u8 *macHdrLocation;
+    u8 interfaceTag;
     CsrBool isDataFrame;
     CsrBool isProtocolVerInvalid = FALSE;
     CsrBool isDataFrameSubTypeNoData = FALSE;
 
 #ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
-    static const CsrUint8 wapiProtocolIdSNAPHeader[] = {0x88,0xb4};
-    static const CsrUint8 wapiProtocolIdSNAPHeaderOffset = 6;
-    CsrUint8 *destAddr;
-    CsrUint8 *srcAddr;
+    static const u8 wapiProtocolIdSNAPHeader[] = {0x88,0xb4};
+    static const u8 wapiProtocolIdSNAPHeaderOffset = 6;
+    u8 *destAddr;
+    u8 *srcAddr;
     CsrBool isWapiUnicastPkt = FALSE;
 
 #ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
     CsrUint16 qosControl;
 #endif
 
-    CsrUint8 llcSnapHeaderOffset = 0;
+    u8 llcSnapHeaderOffset = 0;
 
-    destAddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET;
-    srcAddr  = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET;
+    destAddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET;
+    srcAddr  = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET;
 
     /*Individual/Group bit - Bit 0 of first byte*/
     isWapiUnicastPkt = (!(destAddr[0] & 0x01)) ? TRUE : FALSE;
@@ -129,7 +129,7 @@ static CsrBool check_routing_pkt_data_ind(unifi_priv_t *priv,
     *freeBulkData = FALSE;
 
     /* Fetch the MAC header location from  MA_PKT_IND packet */
-    macHdrLocation = (CsrUint8 *) bulkdata->d[0].os_data_ptr;
+    macHdrLocation = (u8 *) bulkdata->d[0].os_data_ptr;
     /* Fetch the Frame Control value from  MAC header */
     frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation);
 
@@ -286,7 +286,7 @@ static CsrBool check_routing_pkt_data_ind(unifi_priv_t *priv,
         if (llcSnapHeaderOffset > 0) {
                 /* QoS data or Data */
             unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): SNAP header found & its offset %d\n",llcSnapHeaderOffset);
-            if (memcmp((CsrUint8 *)(bulkdata->d[0].os_data_ptr+llcSnapHeaderOffset+wapiProtocolIdSNAPHeaderOffset),
+            if (memcmp((u8 *)(bulkdata->d[0].os_data_ptr+llcSnapHeaderOffset+wapiProtocolIdSNAPHeaderOffset),
                        wapiProtocolIdSNAPHeader,sizeof(wapiProtocolIdSNAPHeader))) {
 
                 unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): This is a data & NOT a WAI protocol packet\n");
@@ -310,8 +310,8 @@ static CsrBool check_routing_pkt_data_ind(unifi_priv_t *priv,
             if((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2P)&&\
                ((CSR_WIFI_80211_GET_FRAME_SUBTYPE(macHdrLocation)) == CSR_WIFI_80211_FRAME_SUBTYPE_BEACON)){
 
-                CsrUint8 *pSsid, *pSsidLen;
-                static CsrUint8 P2PWildCardSsid[CSR_WIFI_P2P_WILDCARD_SSID_LENGTH] = {'D', 'I', 'R', 'E', 'C', 'T', '-'};
+                u8 *pSsid, *pSsidLen;
+                static u8 P2PWildCardSsid[CSR_WIFI_P2P_WILDCARD_SSID_LENGTH] = {'D', 'I', 'R', 'E', 'C', 'T', '-'};
 
                 pSsidLen = macHdrLocation + MAC_HEADER_SIZE + CSR_WIFI_BEACON_FIXED_LENGTH;
                 pSsid = pSsidLen + 2;
@@ -367,7 +367,7 @@ static CsrBool check_routing_pkt_data_ind(unifi_priv_t *priv,
  */
 static void
 unifi_process_receive_event(void *ospriv,
-                            CsrUint8 *sigdata, CsrUint32 siglen,
+                            u8 *sigdata, CsrUint32 siglen,
                             const bulk_data_param_t *bulkdata)
 {
     unifi_priv_t *priv = (unifi_priv_t*)ospriv;
@@ -400,7 +400,7 @@ unifi_process_receive_event(void *ospriv,
     if (signal_id == CSR_MA_PACKET_INDICATION_ID)
     {
 #define CSR_MA_PACKET_INDICATION_INTERFACETAG_OFFSET    14
-        CsrUint8 interfaceTag;
+        u8 interfaceTag;
         netInterface_priv_t *interfacePriv;
 
         /* Pull out interface tag from virtual interface identifier */
@@ -411,9 +411,9 @@ unifi_process_receive_event(void *ospriv,
 #ifdef CSR_SUPPORT_SME
         if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_IBSS)
         {
-            CsrUint8 *saddr;
+            u8 *saddr;
             /* Fetch the source address from  mac header */
-            saddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET;
+            saddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET;
             unifi_trace(priv, UDBG5,
                                     "Updating sta activity in IBSS interfaceTag %x Src Addr %x:%x:%x:%x:%x:%x\n",
                                     interfaceTag, saddr[0], saddr[1], saddr[2], saddr[3], saddr[4], saddr[5]);
@@ -466,7 +466,7 @@ unifi_process_receive_event(void *ospriv,
 #if (defined(CSR_SUPPORT_SME) && defined(CSR_WIFI_SECURITY_WAPI_ENABLE))
                    #define CSR_MA_PACKET_INDICATION_RECEPTION_STATUS_OFFSET    sizeof(CSR_SIGNAL_PRIMITIVE_HEADER) + 22
                    netInterface_priv_t *interfacePriv;
-                   CsrUint8 interfaceTag;
+                   u8 interfaceTag;
                    CsrUint16 receptionStatus = CSR_RX_SUCCESS;
 
                    /* Pull out interface tag from virtual interface identifier */
@@ -487,7 +487,7 @@ unifi_process_receive_event(void *ospriv,
                        ))
                    {
                        CSR_SIGNAL signal;
-                       CsrUint8 *destAddr;
+                       u8 *destAddr;
                        CsrResult res;
                        CsrUint16 interfaceTag = 0;
                        CsrBool isMcastPkt = TRUE;
@@ -501,7 +501,7 @@ unifi_process_receive_event(void *ospriv,
                        }
 
                        /* Check if the type of MPDU and the respective filter status*/
-                       destAddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET;
+                       destAddr = (u8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET;
                        isMcastPkt = (destAddr[0] & 0x01) ? TRUE : FALSE;
                        unifi_trace(priv, UDBG6,
                                    "1.MPDU type: (%s), 2.Multicast filter: (%s), 3. Unicast filter: (%s)\n",
@@ -516,7 +516,7 @@ unifi_process_receive_event(void *ospriv,
                           )
                         {
                             unifi_trace(priv, UDBG4, "Sending the WAPI MPDU for MIC check\n");
-                            CsrWifiRouterCtrlWapiRxMicCheckIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, siglen, sigdata, bulkdata->d[0].data_length, (CsrUint8*)bulkdata->d[0].os_data_ptr);
+                            CsrWifiRouterCtrlWapiRxMicCheckIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, siglen, sigdata, bulkdata->d[0].data_length, (u8*)bulkdata->d[0].os_data_ptr);
 
                             for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
                                 if (bulkdata->d[i].data_length != 0) {
@@ -591,7 +591,7 @@ void unifi_rx_queue_flush(void *ospriv)
     unifi_trace(priv, UDBG4, "rx_wq_handler: RdPtr = %d WritePtr =  %d\n",
                 priv->rxSignalBuffer.readPointer,priv->rxSignalBuffer.writePointer);
     if(priv != NULL) {
-        CsrUint8 readPointer = priv->rxSignalBuffer.readPointer;
+        u8 readPointer = priv->rxSignalBuffer.readPointer;
         while (readPointer != priv->rxSignalBuffer.writePointer)
         {
              rx_buff_struct_t *buf = &priv->rxSignalBuffer.rx_buff[readPointer];
@@ -647,12 +647,12 @@ void rx_wq_handler(struct work_struct *work)
  */
 void
 unifi_receive_event(void *ospriv,
-                    CsrUint8 *sigdata, CsrUint32 siglen,
+                    u8 *sigdata, CsrUint32 siglen,
                     const bulk_data_param_t *bulkdata)
 {
 #ifdef CSR_WIFI_RX_PATH_SPLIT
     unifi_priv_t *priv = (unifi_priv_t*)ospriv;
-    CsrUint8 writePointer;
+    u8 writePointer;
     int i;
     rx_buff_struct_t * rx_buff;
     func_enter();
diff --git a/drivers/staging/csr/unifi_pdu_processing.c b/drivers/staging/csr/unifi_pdu_processing.c
index 45c69a9d383..3c0491b0d31 100644
--- a/drivers/staging/csr/unifi_pdu_processing.c
+++ b/drivers/staging/csr/unifi_pdu_processing.c
@@ -56,15 +56,15 @@ 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,
-                          CSR_PROCESS_ID leSenderProcessId, CsrUint8 *peerMacAddress,
+                          CSR_PROCESS_ID leSenderProcessId, u8 *peerMacAddress,
                           CSR_SIGNAL *signal)
 {
 
     CSR_MA_PACKET_REQUEST *req = &signal->u.MaPacketRequest;
     netInterface_priv_t *interfacePriv;
-    CsrUint8 ba_session_idx = 0;
+    u8 ba_session_idx = 0;
     ba_session_tx_struct *ba_session = NULL;
-    CsrUint8 *ba_addr = NULL;
+    u8 *ba_addr = NULL;
 
     interfacePriv = priv->interfacePriv[interfaceTag];
 
@@ -135,8 +135,8 @@ int frame_and_send_queued_pdu(unifi_priv_t* priv,tx_buffered_packets_t* buffered
     CSR_SIGNAL signal;
     bulk_data_param_t bulkdata;
     int result;
-    CsrUint8 toDs, fromDs, macHeaderLengthInBytes = MAC_HEADER_SIZE;
-    CsrUint8 *qc;
+    u8 toDs, fromDs, macHeaderLengthInBytes = MAC_HEADER_SIZE;
+    u8 *qc;
     CsrUint16 *fc = (CsrUint16*)(buffered_pkt->bulkdata.os_data_ptr);
     unsigned long lock_flags;
     unifi_trace(priv, UDBG3, "frame_and_send_queued_pdu with moreData: %d , EOSP: %d\n",moreData,eosp);
@@ -180,9 +180,9 @@ int frame_and_send_queued_pdu(unifi_priv_t* priv,tx_buffered_packets_t* buffered
                 /* If order bit set then HT control field is the part of MAC header */
                 if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
                     macHeaderLengthInBytes += HT_CONTROL_HEADER_SIZE;
-                    qc = (CsrUint8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-6));
+                    qc = (u8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-6));
                 } else {
-                    qc = (CsrUint8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-2));
+                    qc = (u8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-2));
                 }
                 *qc = eosp ? *qc | (1 << 4) : *qc & (~(1 << 4));
                 break;
@@ -299,7 +299,7 @@ void verify_and_accomodate_tx_packet(unifi_priv_t *priv)
     unsigned long lock_flags;
     struct list_head *listHead, *list;
     struct list_head *placeHolder;
-    CsrUint8 i, j,eospFramedeleted=0;
+    u8 i, j,eospFramedeleted=0;
     CsrBool thresholdExcedeDueToBroadcast = TRUE;
     /* it will be made it interface Specific in the future when multi interfaces are supported ,
     right now interface 0 is considered */
@@ -477,7 +477,7 @@ CsrResult unifi_reque_ma_packet_request (void *ospriv, CsrUint32 host_tag,
     unifi_trace(priv, UDBG6, "unifi_reque_ma_packet_request: host_tag = 0x%x\n", host_tag);
 
     staRecord = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,
-                                                                    (((CsrUint8 *) bulkDataDesc->os_data_ptr) + 4),
+                                                                    (((u8 *) bulkDataDesc->os_data_ptr) + 4),
                                                                     interfaceTag);
     if (NULL == staRecord) {
         unifi_trace(priv, UDBG5, "unifi_reque_ma_packet_request: Invalid STA record \n");
@@ -532,7 +532,7 @@ CsrResult unifi_reque_ma_packet_request (void *ospriv, CsrUint32 host_tag,
         /* Extract the Packet priority */
         if (TRUE == staRecord->wmmOrQosEnabled) {
             CsrUint16 qosControl = 0;
-            CsrUint8  dataFrameType = 0;
+            u8  dataFrameType = 0;
 
             dataFrameType =((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> 4);
 
@@ -603,9 +603,9 @@ CsrResult unifi_reque_ma_packet_request (void *ospriv, CsrUint32 host_tag,
 }
 #endif
 
-static void is_all_ac_deliver_enabled_and_moredata(CsrWifiRouterCtrlStaInfo_t *staRecord, CsrUint8 *allDeliveryEnabled, CsrUint8 *dataAvailable)
+static void is_all_ac_deliver_enabled_and_moredata(CsrWifiRouterCtrlStaInfo_t *staRecord, u8 *allDeliveryEnabled, u8 *dataAvailable)
 {
-    CsrUint8 i;
+    u8 i;
     *allDeliveryEnabled = TRUE;
     for (i = 0 ;i < MAX_ACCESS_CATOGORY; i++) {
         if (!IS_DELIVERY_ENABLED(staRecord->powersaveMode[i])) {
@@ -637,15 +637,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)
 {
-    CsrUint8 handle = CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId);
-    CsrUint8 timSetStatus = CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId);
+    u8 handle = CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId);
+    u8 timSetStatus = CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId);
     CsrUint16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
     CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
     /* This variable holds what TIM value we wanted to set in firmware */
     CsrUint16 timSetValue = 0;
     /* Irrespective of interface the count maintained */
-    static CsrUint8 retryCount = 0;
+    static u8 retryCount = 0;
     unsigned long lock_flags;
     unifi_trace(priv, UDBG3, "entering %s, handle = %x, timSetStatus = %x\n", __FUNCTION__, handle, timSetStatus);
 
@@ -774,7 +774,7 @@ void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, CsrUin
                                 !list_empty(&staRecord->mgtFrames));
                     } else {
                         /* Peer is QSTA */
-                        CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+                        u8 allDeliveryEnabled = 0, dataAvailable = 0;
                         /* Check if all AC's are Delivery Enabled */
                         is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
                         /*check for more data in non-delivery enabled queues*/
@@ -859,14 +859,14 @@ 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, CsrUint8 setTim, CsrUint16 interfaceTag, CsrUint32 handle)
+void update_tim(unifi_priv_t * priv, CsrUint16 aid, u8 setTim, CsrUint16 interfaceTag, CsrUint32 handle)
 {
     CSR_SIGNAL signal;
     CsrInt32 r;
     CSR_MLME_SET_TIM_REQUEST *req = &signal.u.MlmeSetTimRequest;
     bulk_data_param_t *bulkdata = NULL;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
-    CsrUint8 senderIdLsb = 0;
+    u8 senderIdLsb = 0;
     CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
     CsrUint32 oldTimSetStatus = 0, timSetStatus = 0;
 
@@ -998,7 +998,7 @@ void process_peer_active_transition(unifi_priv_t * priv,
             spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
             list_add(&buffered_pkt->q, &staRecord->mgtFrames);
             spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
-            priv->pausedStaHandle[3]=(CsrUint8)(staRecord->assignedHandle);
+            priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
             spaceAvail[3] = FALSE;
             break;
         } else {
@@ -1040,7 +1040,7 @@ void process_peer_active_transition(unifi_priv_t * priv,
                spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
                list_add(&buffered_pkt->q, &staRecord->dataPdu[i]);
                spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
-               priv->pausedStaHandle[i]=(CsrUint8)(staRecord->assignedHandle);
+               priv->pausedStaHandle[i]=(u8)(staRecord->assignedHandle);
                break;
            } else {
               if(r){
@@ -1075,7 +1075,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)
 {
     netInterface_priv_t *interfacePriv;
-    CsrUint8 i;
+    u8 i;
     CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
     interfacePriv = priv->interfacePriv[interfaceTag];
 
@@ -1148,7 +1148,7 @@ void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,CsrUint16 interfaceTag, con
                 if (inactive_time >= STA_INACTIVE_TIMEOUT_VAL)
                 {
                     struct list_head send_cfm_list;
-                    CsrUint8 j;
+                    u8 j;
 
                     /* The SME/NME may be waiting for confirmation for requested frames to this station.
                      * Though this is --VERY UNLIKELY-- in case of station in active mode. But still as a
@@ -1256,17 +1256,17 @@ 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,
-                            CsrUint8 macHeaderLengthInBytes,
-                            CsrUint8 qosDestination)
+                            u8 macHeaderLengthInBytes,
+                            u8 qosDestination)
 {
 
     CsrUint16 *fc = NULL;
-    CsrUint8 direction = 0, toDs, fromDs;
-    CsrUint8 *bufPtr = NULL;
-    CsrUint8 sa[ETH_ALEN], da[ETH_ALEN];
+    u8 direction = 0, toDs, fromDs;
+    u8 *bufPtr = NULL;
+    u8 sa[ETH_ALEN], da[ETH_ALEN];
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
     int headroom;
-    CsrUint8 macHeaderBuf[IEEE802_11_DATA_FRAME_MAC_HEADER_SIZE] = {0};
+    u8 macHeaderBuf[IEEE802_11_DATA_FRAME_MAC_HEADER_SIZE] = {0};
 
     unifi_trace(priv, UDBG5, "entering the update_macheader function\n");
 
@@ -1348,7 +1348,7 @@ static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
                     unifi_trace(priv, UDBG1, " sufficient headroom not there to push updated mac header \n");
                     return -1;
                 }
-                bufPtr = (CsrUint8 *) skb_push(skb, macHeaderLengthInBytes);
+                bufPtr = (u8 *) skb_push(skb, macHeaderLengthInBytes);
 
                 /*  update bulk data os_data_ptr */
                 bulkdata->d[0].os_data_ptr = skb->data;
@@ -1357,11 +1357,11 @@ static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
 
             } else {
                 /* pointing to QOS control field */
-                CsrUint8 qc;
+                u8 qc;
                 if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
-                    qc = *((CsrUint8*)(macHeaderBuf + (macHeaderLengthInBytes - 4 - 2)));
+                    qc = *((u8*)(macHeaderBuf + (macHeaderLengthInBytes - 4 - 2)));
                 } else {
-                    qc = *((CsrUint8*)(macHeaderBuf + (macHeaderLengthInBytes - 2)));
+                    qc = *((u8*)(macHeaderBuf + (macHeaderLengthInBytes - 2)));
                 }
 
                 if ((qc & IEEE802_11_QC_TID_MASK) > 7) {
@@ -1376,7 +1376,7 @@ static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
                     unifi_trace(priv, UDBG3, " sufficient headroom not there to push updated mac header \n");
                     return -1;
                 }
-                bufPtr = (CsrUint8 *) skb_push(skb, macHeaderLengthInBytes);
+                bufPtr = (u8 *) skb_push(skb, macHeaderLengthInBytes);
             }
             break;
         default:
@@ -1386,7 +1386,7 @@ static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
                 unifi_trace(priv, UDBG5, "normal Data packet, NO QOS \n");
 
                 if (qosDestination) {
-                    CsrUint8 qc = 0;
+                    u8 qc = 0;
                     unifi_trace(priv, UDBG3, "destination is QOS station \n");
 
                     /* Set Ma-Packet.req UP to UP0 */
@@ -1428,13 +1428,13 @@ static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
                         bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
                         bulkdata->d[0].data_length = newSkb->len;
 
-                        bufPtr = (CsrUint8*)data_ptrs.d[0].os_data_ptr;
+                        bufPtr = (u8*)data_ptrs.d[0].os_data_ptr;
 
                         /* The old skb will not be used again */
                         kfree_skb(skb);
                     } else {
                         /* skb headroom is sufficient to append Macheader */
-                        bufPtr = (CsrUint8*)skb_push(skb, macHeaderLengthInBytes);
+                        bufPtr = (u8*)skb_push(skb, macHeaderLengthInBytes);
                         bulkdata->d[0].os_data_ptr = skb->data;
                         bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
                         bulkdata->d[0].data_length = skb->len;
@@ -1458,13 +1458,13 @@ static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
                         bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
                         bulkdata->d[0].data_length = newSkb->len;
 
-                        bufPtr = (CsrUint8*)data_ptrs.d[0].os_data_ptr;
+                        bufPtr = (u8*)data_ptrs.d[0].os_data_ptr;
 
                         /* The old skb will not be used again */
                         kfree_skb(skb);
                     } else {
                         /* skb headroom is sufficient to append Macheader */
-                        bufPtr = (CsrUint8*)skb_push(skb, macHeaderLengthInBytes);
+                        bufPtr = (u8*)skb_push(skb, macHeaderLengthInBytes);
                         bulkdata->d[0].os_data_ptr = skb->data;
                         bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
                         bulkdata->d[0].data_length = skb->len;
@@ -1507,7 +1507,7 @@ uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
                        struct ethhdr *ehdr, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
                        const CSR_SIGNAL *signal,
                        bulk_data_param_t *bulkdata,
-                       CsrUint8 macHeaderLengthInBytes)
+                       u8 macHeaderLengthInBytes)
 {
     const CSR_MA_PACKET_INDICATION *ind = &(signal->u.MaPacketIndication);
     CsrUint16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0x00ff);
@@ -1643,7 +1643,7 @@ uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
 #endif
 
 CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
-                                   CsrUint8 *peerMacAddress,
+                                   u8 *peerMacAddress,
                                    CSR_CLIENT_TAG hostTag,
                                    CsrUint16 interfaceTag,
                                    CSR_TRANSMISSION_CONTROL transmissionControl,
@@ -1657,7 +1657,7 @@ CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
     int result;
 #ifdef CSR_SUPPORT_SME
    CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
-    const CsrUint8 *macHdrLocation =  bulkdata->d[0].os_data_ptr;
+    const u8 *macHdrLocation =  bulkdata->d[0].os_data_ptr;
     CsrWifiPacketType pktType;
     int frameType = 0;
     CsrBool queuePacketDozing = FALSE;
@@ -1800,7 +1800,7 @@ CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
                                 list = &staRecord->mgtFrames;
                                 requeueOnSamePos = TRUE;
                                 unifi_trace(priv, UDBG1, "(ENOSPC) Sending MgtFrames Failed handle = %d so buffering\n",staRecord->assignedHandle);
-                                priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+                                priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
                             } else if (result) {
                                 status = CSR_RESULT_FAILURE;
                             }
@@ -1847,7 +1847,7 @@ CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
                             unifi_trace(priv, UDBG1, "(ENOSPC) Sending Unicast DataPDU to queue %d Failed so buffering\n",priority_q);
                             requeueOnSamePos = TRUE;
                             list = &staRecord->dataPdu[priority_q];
-                            priv->pausedStaHandle[priority_q]=(CsrUint8)(staRecord->assignedHandle);
+                            priv->pausedStaHandle[priority_q]=(u8)(staRecord->assignedHandle);
                             if(!isRouterBufferEnabled(priv,priority_q)) {
                                 unifi_error(priv,"Buffering Not enabled for queue %d \n",priority_q);
                             }
@@ -1928,7 +1928,7 @@ CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
                 }
             } else {
                 /* Check for non delivery enable(i.e trigger enable), all delivery enable & legacy AC for TIM update in firmware */
-                CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+                u8 allDeliveryEnabled = 0, dataAvailable = 0;
                 /* Check if all AC's are Delivery Enabled */
                 is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
                 if (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable)
@@ -1976,7 +1976,7 @@ CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
 }
 
 #ifdef CSR_SUPPORT_SME
-CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *daddr)
+CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *daddr)
 {
     CsrInt8 protection = 0;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
@@ -2017,12 +2017,12 @@ CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 i
 }
 #endif
 #ifdef CSR_SUPPORT_SME
-CsrUint8 send_multicast_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
+u8 send_multicast_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
 {
     int r;
     tx_buffered_packets_t * buffered_pkt = NULL;
     CsrBool moreData = FALSE;
-    CsrUint8 pduSent =0;
+    u8 pduSent =0;
     unsigned long lock_flags;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
     CsrUint32 hostTag = 0xffffffff;
@@ -2115,7 +2115,7 @@ CsrUint8 send_multicast_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
     return pduSent;
 }
 #endif
-void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,CsrUint8 *sigdata,
+void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata,
                                         CsrUint32 siglen)
 {
 #ifdef CSR_SUPPORT_SME
@@ -2123,7 +2123,7 @@ void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,CsrUint8 *sigdata,
     CSR_MA_VIF_AVAILABILITY_INDICATION *ind;
     int r;
     CsrUint16 interfaceTag;
-    CsrUint8 pduSent =0;
+    u8 pduSent =0;
     CSR_RESULT_CODE resultCode = CSR_RC_SUCCESS;
     netInterface_priv_t *interfacePriv;
 
@@ -2261,7 +2261,7 @@ static CsrBool uf_is_more_data_for_usp_delivery(unifi_priv_t *priv, CsrWifiRoute
  */
 void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv,
                                             CsrWifiRouterCtrlStaInfo_t * staInfo,
-                                            CsrUint8 queue,
+                                            u8 queue,
                                             struct list_head *txList)
 {
 
@@ -2337,7 +2337,7 @@ void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv,
             spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
             list_add(&buffered_pkt->q,txList);
             spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
-            priv->pausedStaHandle[queue]=(CsrUint8)(staInfo->assignedHandle);
+            priv->pausedStaHandle[queue]=(u8)(staInfo->assignedHandle);
             break;
         } else {
             if(r){
@@ -2363,7 +2363,7 @@ void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv,
 
 void uf_send_buffered_data_from_ac(unifi_priv_t *priv,
                                    CsrWifiRouterCtrlStaInfo_t * staInfo,
-                                   CsrUint8 queue,
+                                   u8 queue,
                                    struct list_head *txList)
 {
     tx_buffered_packets_t * buffered_pkt = NULL;
@@ -2390,7 +2390,7 @@ void uf_send_buffered_data_from_ac(unifi_priv_t *priv,
            list_add(&buffered_pkt->q,txList);
            spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
            if(staInfo != NULL){
-              priv->pausedStaHandle[queue]=(CsrUint8)(staInfo->assignedHandle);
+              priv->pausedStaHandle[queue]=(u8)(staInfo->assignedHandle);
            }
            unifi_trace(priv,UDBG3," uf_send_buffered_data_from_ac: PDU sending failed .. no space for queue %d \n",queue);
            } else {
@@ -2411,7 +2411,7 @@ void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue q)
     CsrUint16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
     CsrUint32 startIndex=0,endIndex=0;
     CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
-    CsrUint8 queue;
+    u8 queue;
     CsrBool moreData = FALSE;
 
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
@@ -2551,7 +2551,7 @@ void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue q)
 
 CsrBool uf_is_more_data_for_non_delivery_ac(CsrWifiRouterCtrlStaInfo_t *staRecord)
 {
-    CsrUint8 i;
+    u8 i;
 
     for(i=0;i<=3;i++)
     {
@@ -2640,7 +2640,7 @@ static void uf_handle_uspframes_delivery(unifi_priv_t * priv, CsrWifiRouterCtrlS
 {
 
     CsrInt8 i;
-    CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+    u8 allDeliveryEnabled = 0, dataAvailable = 0;
     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
     unsigned long lock_flags;
 
@@ -2720,7 +2720,7 @@ static void uf_handle_uspframes_delivery(unifi_priv_t * priv, CsrWifiRouterCtrlS
     is_all_ac_deliver_enabled_and_moredata(staInfo, &allDeliveryEnabled, &dataAvailable);
     if ((allDeliveryEnabled && !dataAvailable)) {
         if ((staInfo->timSet != CSR_WIFI_TIM_RESET) || (staInfo->timSet != CSR_WIFI_TIM_RESETTING)) {
-            staInfo->updateTimReqQueued = (CsrUint8) CSR_WIFI_TIM_RESET;
+            staInfo->updateTimReqQueued = (u8) CSR_WIFI_TIM_RESET;
             unifi_trace(priv, UDBG4, " --uf_handle_uspframes_delivery, UAPSD timset\n");
             if (!staInfo->timRequestPendingFlag) {
                 update_tim(priv, staInfo->aid, 0, interfaceTag, staInfo->assignedHandle);
@@ -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 CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
+void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
 {
     bulk_data_param_t bulkdata;
     CsrResult csrResult;
@@ -2798,7 +2798,7 @@ void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8
         unifi_net_data_free(priv, &bulkdata.d[0]);
         return;
     }
-    memcpy(peerAddress.a, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+    memcpy(peerAddress.a, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
     /* convert priority to queue */
     priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
 
@@ -2830,7 +2830,7 @@ void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8
     return;
 
 }
-void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
+void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
 {
     bulk_data_param_t bulkdata;
     CsrResult csrResult;
@@ -2868,7 +2868,7 @@ void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8
         unifi_net_data_free(priv, &bulkdata.d[0]);
         return;
     }
-    memcpy(peerAddress.a, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+    memcpy(peerAddress.a, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
     /* convert priority to queue */
     priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
     transmissionControl &= ~(CSR_NO_CONFIRM_REQUIRED);
@@ -2918,9 +2918,9 @@ void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8
 
 CsrBool uf_check_broadcast_bssid(unifi_priv_t *priv, const bulk_data_param_t *bulkdata)
 {
-    CsrUint8 *bssid = NULL;
+    u8 *bssid = NULL;
     static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
-    CsrUint8 toDs, fromDs;
+    u8 toDs, fromDs;
 
     toDs = (((bulkdata->d[0].os_data_ptr)[1]) & 0x01) ? 1 : 0;
     fromDs =(((bulkdata->d[0].os_data_ptr)[1]) & 0x02) ? 1 : 0;
@@ -2933,17 +2933,17 @@ CsrBool uf_check_broadcast_bssid(unifi_priv_t *priv, const bulk_data_param_t *bu
     else if((toDs == 0) && (fromDs ==0))
     {
         /* BSSID is Address 3 */
-        bssid = (CsrUint8 *) (bulkdata->d[0].os_data_ptr + 4 + (2 * ETH_ALEN));
+        bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4 + (2 * ETH_ALEN));
     }
     else if(toDs)
     {
         /* BSSID is Address 1 */
-        bssid = (CsrUint8 *) (bulkdata->d[0].os_data_ptr + 4);
+        bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4);
     }
     else if(fromDs)
     {
         /* BSSID is Address 2 */
-        bssid = (CsrUint8 *) (bulkdata->d[0].os_data_ptr + 4 + ETH_ALEN);
+        bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4 + ETH_ALEN);
     }
 
     if (memcmp(broadcast_address.a, bssid, ETH_ALEN)== 0)
@@ -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,
-                                CsrUint8 pmBit,CsrUint16 interfaceTag)
+                                u8 pmBit,CsrUint16 interfaceTag)
 {
     CsrBool moreData = FALSE;
     CsrBool powerSaveChanged = FALSE;
@@ -3023,7 +3023,7 @@ CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo
 
             }
         } else {
-            CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+            u8 allDeliveryEnabled = 0, dataAvailable = 0;
             unifi_trace(priv, UDBG5, "Qos in AP Mode\n");
             /* Check if all AC's are Delivery Enabled */
             is_all_ac_deliver_enabled_and_moredata(srcStaInfo, &allDeliveryEnabled, &dataAvailable);
@@ -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,CsrUint8* sa,CsrUint8* da,CsrUint8 pmBit,CsrUint16 interfaceTag)
+void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,CsrUint16 interfaceTag)
 {
     CsrWifiRouterCtrlStaInfo_t *staRecord =
     CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, sa, interfaceTag);
@@ -3105,7 +3105,7 @@ void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pm
                 list_add(&buffered_pkt->q, &staRecord->mgtFrames);
                 spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
                 unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
-                priv->pausedStaHandle[3]=(CsrUint8)(staRecord->assignedHandle);
+                priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
             } else {
                 if(r){
                     unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
@@ -3127,7 +3127,7 @@ void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pm
                 spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
                 list_add(&buffered_pkt->q, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]);
                 spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
-                priv->pausedStaHandle[3]=(CsrUint8)(staRecord->assignedHandle);
+                priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
                 unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
             } else {
                 if(r){
@@ -3149,7 +3149,7 @@ void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pm
                 spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
                 list_add(&buffered_pkt->q, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]);
                 spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
-                priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+                priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
                 unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
             } else {
                 if(r){
@@ -3183,7 +3183,7 @@ void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pm
         }
     } else {
 
-        CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+        u8 allDeliveryEnabled = 0, dataAvailable = 0;
         unifi_trace(priv, UDBG3,"Qos Support station.Processing PS-Poll\n");
 
         /*Send Data From Management Frames*/
@@ -3218,7 +3218,7 @@ void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pm
                         spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
                         list_add(&buffered_pkt->q, &staRecord->mgtFrames);
                         spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
-                        priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+                        priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
                         unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
                     } else {
                         if(r){
@@ -3253,7 +3253,7 @@ void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pm
                             spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
                             list_add(&buffered_pkt->q, &staRecord->dataPdu[i]);
                             spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
-                            priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+                            priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
                             unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
                         } else {
                             if(r) {
@@ -3447,10 +3447,10 @@ 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 CsrUint8 *peerMacAddress,
+        const u8 *peerMacAddress,
         CsrUint16 interfaceTag)
 {
-    CsrUint8 i;
+    u8 i;
     netInterface_priv_t *interfacePriv;
     unsigned long lock_flags;
 
@@ -3527,7 +3527,7 @@ void uf_check_inactivity(unifi_priv_t *priv, CsrUint16 interfaceTag, CsrTime cur
         spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
 
         if (elapsedTime > MAX_INACTIVITY_INTERVAL) {
-            memcpy((CsrUint8*)&peerMacAddress, (CsrUint8*)&staInfo->peerMacAddress, sizeof(CsrWifiMacAddress));
+            memcpy((u8*)&peerMacAddress, (u8*)&staInfo->peerMacAddress, sizeof(CsrWifiMacAddress));
 
             /* Indicate inactivity for the station */
             unifi_trace(priv, UDBG3, "Station %x:%x:%x:%x:%x:%x inactive since %xus\n sending Inactive Ind\n",
@@ -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 CsrUint8 *peerMacAddress)
+void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *peerMacAddress)
 {
     CsrTime elapsedTime, currentTime;    /* Time in microseconds */
     CsrTime timeHi;         /* Not used - Time in microseconds */
@@ -3591,7 +3591,7 @@ void resume_unicast_buffered_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
 {
 
    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
-   CsrUint8 i;
+   u8 i;
    int j;
    tx_buffered_packets_t * buffered_pkt = NULL;
    CsrBool hipslotFree[4] = {TRUE,TRUE,TRUE,TRUE};
@@ -3635,7 +3635,7 @@ void resume_unicast_buffered_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
                   spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
                   list_add(&buffered_pkt->q, &staInfo->mgtFrames);
                   spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
-                  priv->pausedStaHandle[3]=(CsrUint8)(staInfo->assignedHandle);
+                  priv->pausedStaHandle[3]=(u8)(staInfo->assignedHandle);
                   hipslotFree[3] = FALSE;
                   break;
               } else {
@@ -3660,7 +3660,7 @@ void resume_unicast_buffered_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
                      spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
                      list_add(&buffered_pkt->q, &staInfo->dataPdu[j]);
                      spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
-                     priv->pausedStaHandle[j]=(CsrUint8)(staInfo->assignedHandle);
+                     priv->pausedStaHandle[j]=(u8)(staInfo->assignedHandle);
                      hipslotFree[j]=FALSE;
                      break;
                  } else {
@@ -3721,7 +3721,7 @@ void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,CsrUint16 int
 void resume_suspended_uapsd(unifi_priv_t* priv,CsrUint16 interfaceTag)
 {
 
-   CsrUint8 startIndex;
+   u8 startIndex;
    CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
     unsigned long lock_flags;
 
diff --git a/drivers/staging/csr/unifi_priv.h b/drivers/staging/csr/unifi_priv.h
index 7e940ef6acd..666e17f02f6 100644
--- a/drivers/staging/csr/unifi_priv.h
+++ b/drivers/staging/csr/unifi_priv.h
@@ -202,14 +202,14 @@ extern struct wake_lock unifi_sdio_wake_lock;
 #define CSR_WIFI_80211_FRAME_SUBTYPE_BEACON      0x8
 #define CSR_WIFI_BEACON_FIXED_LENGTH             12
 #define CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET        4
-#define CSR_WIFI_80211_FRAME_SUBTYPE_BIT_MASK    ((CsrUint8)(0xF << CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET))
+#define CSR_WIFI_80211_FRAME_SUBTYPE_BIT_MASK    ((u8)(0xF << CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET))
 
 #define CSR_WIFI_80211_GET_FRAME_SUBTYPE(frameBuffer) \
-    ((CsrUint8)(((CsrUint8 *)frameBuffer)[0] & CSR_WIFI_80211_FRAME_SUBTYPE_BIT_MASK) >> CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET)
+    ((u8)(((u8 *)frameBuffer)[0] & CSR_WIFI_80211_FRAME_SUBTYPE_BIT_MASK) >> CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET)
 
 /* For M4 request received via netdev*/
 
-typedef CsrUint8 CsrWifiPacketType;
+typedef u8 CsrWifiPacketType;
 #define CSR_WIFI_UNICAST_PDU   ((CsrWifiPacketType) 0x00)
 #define CSR_WIFI_MULTICAST_PDU ((CsrWifiPacketType) 0x1)
 #define CSR_WIFI_BROADCAST_PDU ((CsrWifiPacketType) 0x2)
@@ -280,7 +280,7 @@ typedef struct rx_buffered_packets {
 } rx_buffered_packets_t;
 
 
-typedef CsrUint8 CsrWifiAcPowersaveMode;
+typedef u8 CsrWifiAcPowersaveMode;
 #define CSR_WIFI_AC_TRIGGER_ONLY_ENABLED 0x00
 #define CSR_WIFI_AC_DELIVERY_ONLY_ENABLE 0X01
 #define CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED 0X03
@@ -351,13 +351,13 @@ typedef struct CsrWifiRouterCtrlStaInfo_t {
     CsrWifiRouterCtrlPeerStatus currentPeerState;
     struct list_head dataPdu[MAX_ACCESS_CATOGORY];
     struct list_head mgtFrames;
-    CsrUint8 spStatus;
-    CsrUint8 prevFrmType;
-    CsrUint8 prevFrmAccessCatogory;
+    u8 spStatus;
+    u8 prevFrmType;
+    u8 prevFrmAccessCatogory;
     CsrBool protection;
     CsrUint16 aid;
     CsrBool txSuspend;
-    CsrUint8 timSet;
+    u8 timSet;
     /* Dont change the value of below macro for SET & RESET */
 #define CSR_WIFI_TIM_RESET       0
 #define CSR_WIFI_TIM_SET         1
@@ -365,7 +365,7 @@ typedef struct CsrWifiRouterCtrlStaInfo_t {
 #define CSR_WIFI_TIM_SETTING     3
 
     CsrBool timRequestPendingFlag;
-    CsrUint8 updateTimReqQueued;
+    u8 updateTimReqQueued;
     CsrUint16 noOfPktQueued;
 }CsrWifiRouterCtrlStaInfo_t;
 
@@ -374,8 +374,8 @@ struct CsrWifiSmeApConfig {
     CsrWifiSsid ssid;
     CsrUint16 channel;
     CsrWifiNmeApCredentials credentials;
-    CsrUint8 max_connections;
-    CsrUint8 if_index;
+    u8 max_connections;
+    u8 if_index;
 };
 #endif
 
@@ -385,16 +385,16 @@ struct CsrWifiSmeApConfig {
 
 typedef struct
 {
-    CsrUint8 *bufptr; /* Signal Primitive */
+    u8 *bufptr; /* Signal Primitive */
     bulk_data_param_t data_ptrs; /* Bulk Data pointers */
     CsrUint16 sig_len;
 }rx_buff_struct_t;
 
 typedef struct
 {
-    CsrUint8 writePointer; /**< write pointer */
-    CsrUint8 readPointer;  /**< read pointer */
-    CsrUint8 size;         /**< size of circular buffer */
+    u8 writePointer; /**< write pointer */
+    u8 readPointer;  /**< read pointer */
+    u8 size;         /**< size of circular buffer */
     rx_buff_struct_t rx_buff[CSR_WIFI_RX_SIGNAL_BUFFER_SIZE];    /**< Element of ciruclar buffer */
 } rxCircularBuffer_t;
 
@@ -427,7 +427,7 @@ struct unifi_priv {
     struct net_device *netdev[CSR_WIFI_NUM_INTERFACES];
     struct netInterface_priv *interfacePriv[CSR_WIFI_NUM_INTERFACES];
 
-    CsrUint8 totalInterfaceCount;
+    u8 totalInterfaceCount;
 
     int prev_queue;
 
@@ -493,8 +493,8 @@ struct unifi_priv {
 #ifdef CSR_SUPPORT_SME
   /* lock to protect the tx queues list */
     spinlock_t tx_q_lock;
-    CsrUint8 allPeerDozing;
-    CsrUint8 pausedStaHandle[MAX_ACCESS_CATOGORY];
+    u8 allPeerDozing;
+    u8 pausedStaHandle[MAX_ACCESS_CATOGORY];
     /* Max packet the driver can queue, irrespective of interface number */
     CsrUint16 noOfPktQueuedInDriver;
 #define CSR_WIFI_DRIVER_SUPPORT_FOR_MAX_PKT_QUEUEING 512
@@ -638,7 +638,7 @@ struct unifi_priv {
     /* Array to indicate if a particular Tx queue is paused, this may not be
      * required in a multiqueue implementation since we can directly stop kernel
      * queues */
-    CsrUint8 tx_q_paused_flag[UNIFI_TRAFFIC_Q_MAX];
+    u8 tx_q_paused_flag[UNIFI_TRAFFIC_Q_MAX];
 #endif
 
 #ifdef CSR_WIFI_RX_PATH_SPLIT
@@ -655,10 +655,10 @@ struct unifi_priv {
 
 #ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
     /*Set if multicast KeyID = 1*/
-    CsrUint8 wapi_multicast_filter;
+    u8 wapi_multicast_filter;
     /*Set if unicast KeyID = 1*/
-    CsrUint8 wapi_unicast_filter;
-    CsrUint8 wapi_unicast_queued_pkt_filter;
+    u8 wapi_unicast_filter;
+    u8 wapi_unicast_queued_pkt_filter;
 #ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
     CsrBool  isWapiConnection;
 #endif
@@ -675,7 +675,7 @@ struct unifi_priv {
 
 typedef struct {
     CsrUint16 queue_length[4];
-    CsrUint8 os_queue_paused;
+    u8 os_queue_paused;
 } unifi_OsQosInfo;
 
 
@@ -716,14 +716,14 @@ typedef struct netInterface_priv
     ba_session_tx_struct *ba_session_tx[MAX_SUPPORTED_BA_SESSIONS_TX];
     ba_session_rx_struct *ba_session_rx[MAX_SUPPORTED_BA_SESSIONS_RX];
     frame_desc_struct ba_complete[MAX_BA_WIND_SIZE];
-    CsrUint8 ba_complete_index;
-    CsrUint8 queueEnabled[UNIFI_NO_OF_TX_QS];
+    u8 ba_complete_index;
+    u8 queueEnabled[UNIFI_NO_OF_TX_QS];
     struct work_struct send_m4_ready_task;
 #ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
     struct work_struct send_pkt_to_encrypt;
 #endif
     struct net_device_stats stats;
-    CsrUint8 interfaceMode;
+    u8 interfaceMode;
     CsrBool protect;
     CsrWifiMacAddress bssid;
     /*
@@ -756,7 +756,7 @@ typedef struct netInterface_priv
     unifi_port_config_t uncontrolled_data_port;
 
     /* station record maintenance related data structures */
-    CsrUint8 num_stations_joined;
+    u8 num_stations_joined;
     CsrWifiRouterCtrlStaInfo_t *(staInfo)[UNIFI_MAX_CONNECTIONS];
     struct list_head genericMgtFrames;
     struct list_head genericMulticastOrBroadCastFrames;
@@ -957,31 +957,31 @@ 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,CsrUint8 pmBit,CsrUint16 interfaceTag);
-void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pmBit,CsrUint16 interfaceTag);
+CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,u8 pmBit,CsrUint16 interfaceTag);
+void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,CsrUint16 interfaceTag);
 int uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
                    struct ethhdr *ehdr, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
                    const CSR_SIGNAL *signal,
                    bulk_data_param_t *bulkdata,
-                   CsrUint8 macHeaderLengthInBytes);
+                   u8 macHeaderLengthInBytes);
 CsrBool uf_is_more_data_for_non_delivery_ac(CsrWifiRouterCtrlStaInfo_t *staRecord);
 void uf_process_wmm_deliver_ac_uapsd (  unifi_priv_t * priv,
                                         CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
                                         CsrUint16 qosControl,
                                         CsrUint16 interfaceTag);
 
-void uf_send_buffered_data_from_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, CsrUint8 queue, struct list_head *txList);
-void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, CsrUint8 queue, struct list_head *txList);
+void uf_send_buffered_data_from_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, u8 queue, struct list_head *txList);
+void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, u8 queue, struct list_head *txList);
 
 void uf_continue_uapsd(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo);
-void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
-void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
+void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
+void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
 
 
 
 #endif
-CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,  CsrUint8 *peerMacAddress, CSR_CLIENT_TAG hostTag, CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl, CSR_RATE TransmitRate, CSR_PRIORITY priority, CSR_PROCESS_ID senderId, bulk_data_param_t *bulkdata);
-void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,CsrUint8 *sigdata, CsrUint32 siglen);
+CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,  u8 *peerMacAddress, CSR_CLIENT_TAG hostTag, CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl, CSR_RATE TransmitRate, CSR_PRIORITY priority, CSR_PROCESS_ID senderId, bulk_data_param_t *bulkdata);
+void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata, CsrUint32 siglen);
 #ifdef CSR_SUPPORT_SME
 void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue queue);
 int uf_process_station_records_for_sending_data(unifi_priv_t *priv,CsrUint16 interfaceTag,
@@ -1029,8 +1029,8 @@ int prepare_and_add_macheader(unifi_priv_t *priv,
                               CSR_PRIORITY priority,
                               bulk_data_param_t *bulkdata,
                               CsrUint16 interfaceTag,
-                              const CsrUint8 *daddr,
-                              const CsrUint8 *saddr,
+                              const u8 *daddr,
+                              const u8 *saddr,
                               CsrBool protection);
 CSR_PRIORITY
 get_packet_priority(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr *ehdr, netInterface_priv_t *interfacePriv);
@@ -1039,21 +1039,21 @@ 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,
-                          CSR_PROCESS_ID leSenderProcessId, CsrUint8 *peerMacAddress,
+                          CSR_PROCESS_ID leSenderProcessId, u8 *peerMacAddress,
                           CSR_SIGNAL *signal);
 
 
 /* Pack the LSB to include station handle & status of tim set */
 #define CSR_WIFI_PACK_SENDER_ID_LSB_FOR_TIM_REQ(handle, timState)  ((handle << 2) | timState)
 /* get the station record handle from the sender ID */
-#define CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId) (CsrUint8) ((receiverProcessId & 0xff) >> 2)
+#define CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId) (u8) ((receiverProcessId & 0xff) >> 2)
 /* get the timSet status from the sender ID */
-#define CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId)  (CsrUint8) (receiverProcessId & 0x03)
+#define CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId)  (u8) (receiverProcessId & 0x03)
 
 /* handle is 6 bits to accomodate in senderId LSB (only 64 station can be associated) */
 #define CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE 0x3F
 
-void update_tim(unifi_priv_t * priv, CsrUint16 aid, CsrUint8 setTim, CsrUint16 interfaceTag, CsrUint32 handle);
+void update_tim(unifi_priv_t * priv, CsrUint16 aid, u8 setTim, CsrUint16 interfaceTag, CsrUint32 handle);
 void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, CsrUint16 senderProcessId);
 
 /* Clear the Peer station Record, in case of wifioff/unexpected card removal */
@@ -1071,13 +1071,13 @@ CsrBool blockack_session_stop(unifi_priv_t *priv,
                               CsrWifiMacAddress macAddress);
 #ifdef CSR_SUPPORT_SME
 /* Fetch the protection information from interface Mode */
-CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *daddr);
+CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *daddr);
 #endif
 
 /* Fetch the station record handler from data base for matching Mac address */
 #ifdef CSR_SUPPORT_SME
 CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(unifi_priv_t *priv,
-                                                                                const CsrUint8 *peerMacAddress,
+                                                                                const u8 *peerMacAddress,
                                                                                 CsrUint16 interfaceTag);
 
 /* Fetch the station record handler from data base for matching handle */
@@ -1085,7 +1085,7 @@ CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_p
                                                                  CsrUint32 handle,
                                                                  CsrUint16 interfaceTag);
 
-void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *peerMacAddress);
+void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const u8 *peerMacAddress);
 void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,CsrUint16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm);
 #endif
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
diff --git a/drivers/staging/csr/unifi_sme.c b/drivers/staging/csr/unifi_sme.c
index 5ad1d5f8167..559213ba8bc 100644
--- a/drivers/staging/csr/unifi_sme.c
+++ b/drivers/staging/csr/unifi_sme.c
@@ -116,13 +116,13 @@ sme_log_event(ul_client_t *pcli,
         {
             CsrUint16 frmCtrl;
             CsrBool unicastPdu = TRUE;
-            CsrUint8 *macHdrLocation;
-            CsrUint8 *raddr = NULL, *taddr = NULL;
+            u8 *macHdrLocation;
+            u8 *raddr = NULL, *taddr = NULL;
             CsrWifiMacAddress peerMacAddress;
             /* Check if we need to send CsrWifiRouterCtrlMicFailureInd*/
             CSR_MA_PACKET_INDICATION *ind = &unpacked_signal.u.MaPacketIndication;
 
-            macHdrLocation = (CsrUint8 *) bulkdata->d[0].os_data_ptr;
+            macHdrLocation = (u8 *) bulkdata->d[0].os_data_ptr;
             /* Fetch the frame control value from  mac header */
             frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation);
 
@@ -146,7 +146,7 @@ sme_log_event(ul_client_t *pcli,
             {
                 if(ind->ReceptionStatus == CSR_RX_SUCCESS)
                 {
-                    CsrUint8 pmBit = (frmCtrl & 0x1000)?0x01:0x00;
+                    u8 pmBit = (frmCtrl & 0x1000)?0x01:0x00;
                     CsrUint16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0xff);
                     CsrWifiRouterCtrlStaInfo_t *srcStaInfo =  CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,taddr,interfaceTag);
                     if((srcStaInfo != NULL) && (uf_check_broadcast_bssid(priv, bulkdata)== FALSE))
@@ -226,11 +226,11 @@ sme_log_event(ul_client_t *pcli,
     }
 
     mlmeCommand.length = signal_len;
-    mlmeCommand.data = (CsrUint8*)signal;
+    mlmeCommand.data = (u8*)signal;
 
     dataref1.length = bulkdata->d[0].data_length;
     if (dataref1.length > 0) {
-        dataref1.data = (CsrUint8 *) bulkdata->d[0].os_data_ptr;
+        dataref1.data = (u8 *) bulkdata->d[0].os_data_ptr;
     } else
     {
         dataref1.data = NULL;
@@ -238,7 +238,7 @@ sme_log_event(ul_client_t *pcli,
 
     dataref2.length = bulkdata->d[1].data_length;
     if (dataref2.length > 0) {
-        dataref2.data = (CsrUint8 *) bulkdata->d[1].os_data_ptr;
+        dataref2.data = (u8 *) bulkdata->d[1].os_data_ptr;
     } else
     {
         dataref2.data = NULL;
@@ -615,10 +615,10 @@ int unifi_cfg_packet_filters(unifi_priv_t *priv, unsigned char *arg)
         dhcp_tclas->user_priority = 0;
         dhcp_tclas->tcp_ip_cls_fr.cls_fr_type = 1;
         dhcp_tclas->tcp_ip_cls_fr.version = 4;
-        ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[0] = 0x00;
-        ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[1] = 0x44;
-        ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[0] = 0x00;
-        ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[1] = 0x43;
+        ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[0] = 0x00;
+        ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[1] = 0x44;
+        ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[0] = 0x00;
+        ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[1] = 0x43;
         dhcp_tclas->tcp_ip_cls_fr.protocol = 0x11;
         dhcp_tclas->tcp_ip_cls_fr.cls_fr_mask = 0x58; //bits: 3,4,6
     }
@@ -631,10 +631,10 @@ int unifi_cfg_packet_filters(unifi_priv_t *priv, unsigned char *arg)
 
 int unifi_cfg_wmm_qos_info(unifi_priv_t *priv, unsigned char *arg)
 {
-    CsrUint8 wmm_qos_info;
+    u8 wmm_qos_info;
     int rc = 0;
 
-    if (get_user(wmm_qos_info, (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1))) {
+    if (get_user(wmm_qos_info, (u8*)(((unifi_cfg_command_t*)arg) + 1))) {
         unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
         return -EFAULT;
     }
@@ -649,21 +649,21 @@ int unifi_cfg_wmm_qos_info(unifi_priv_t *priv, unsigned char *arg)
 int unifi_cfg_wmm_addts(unifi_priv_t *priv, unsigned char *arg)
 {
     CsrUint32 addts_tid;
-    CsrUint8 addts_ie_length;
-    CsrUint8 *addts_ie;
-    CsrUint8 *addts_params;
+    u8 addts_ie_length;
+    u8 *addts_ie;
+    u8 *addts_params;
     CsrWifiSmeDataBlock tspec;
     CsrWifiSmeDataBlock tclas;
     int rc;
 
-    addts_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+    addts_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
     if (get_user(addts_tid, (CsrUint32*)addts_params)) {
         unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n");
         return -EFAULT;
     }
 
     addts_params += sizeof(CsrUint32);
-    if (get_user(addts_ie_length, (CsrUint8*)addts_params)) {
+    if (get_user(addts_ie_length, (u8*)addts_params)) {
         unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n");
         return -EFAULT;
     }
@@ -679,7 +679,7 @@ int unifi_cfg_wmm_addts(unifi_priv_t *priv, unsigned char *arg)
         return -ENOMEM;
     }
 
-    addts_params += sizeof(CsrUint8);
+    addts_params += sizeof(u8);
     rc = copy_from_user(addts_ie, addts_params, addts_ie_length);
     if (rc) {
         unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the addts buffer\n");
@@ -703,12 +703,12 @@ int unifi_cfg_wmm_addts(unifi_priv_t *priv, unsigned char *arg)
 int unifi_cfg_wmm_delts(unifi_priv_t *priv, unsigned char *arg)
 {
     CsrUint32 delts_tid;
-    CsrUint8 *delts_params;
+    u8 *delts_params;
     CsrWifiSmeDataBlock tspec;
     CsrWifiSmeDataBlock tclas;
     int rc;
 
-    delts_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+    delts_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
     if (get_user(delts_tid, (CsrUint32*)delts_params)) {
         unifi_error(priv, "unifi_cfg_wmm_delts: Failed to get the argument\n");
         return -EFAULT;
@@ -728,13 +728,13 @@ int unifi_cfg_wmm_delts(unifi_priv_t *priv, unsigned char *arg)
 int unifi_cfg_strict_draft_n(unifi_priv_t *priv, unsigned char *arg)
 {
     CsrBool strict_draft_n;
-    CsrUint8 *strict_draft_n_params;
+    u8 *strict_draft_n_params;
     int rc;
 
     CsrWifiSmeStaConfig  staConfig;
     CsrWifiSmeDeviceConfig  deviceConfig;
 
-    strict_draft_n_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+    strict_draft_n_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
     if (get_user(strict_draft_n, (CsrBool*)strict_draft_n_params)) {
         unifi_error(priv, "unifi_cfg_strict_draft_n: Failed to get the argument\n");
         return -EFAULT;
@@ -764,13 +764,13 @@ int unifi_cfg_strict_draft_n(unifi_priv_t *priv, unsigned char *arg)
 int unifi_cfg_enable_okc(unifi_priv_t *priv, unsigned char *arg)
 {
     CsrBool enable_okc;
-    CsrUint8 *enable_okc_params;
+    u8 *enable_okc_params;
     int rc;
 
     CsrWifiSmeStaConfig staConfig;
     CsrWifiSmeDeviceConfig deviceConfig;
 
-    enable_okc_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+    enable_okc_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
     if (get_user(enable_okc, (CsrBool*)enable_okc_params)) {
         unifi_error(priv, "unifi_cfg_enable_okc: Failed to get the argument\n");
         return -EFAULT;
@@ -911,7 +911,7 @@ int unifi_cfg_get_info(unifi_priv_t *priv, unsigned char *arg)
 }
 #ifdef CSR_SUPPORT_WEXT_AP
 int
- uf_configure_supported_rates(CsrUint8 * supportedRates, CsrUint8 phySupportedBitmap)
+ uf_configure_supported_rates(u8 * supportedRates, u8 phySupportedBitmap)
 {
     int i=0;
     CsrBool b=FALSE, g = FALSE, n = FALSE;
@@ -1199,7 +1199,7 @@ void uf_send_pkt_to_encrypt(struct work_struct *work)
     unifi_priv_t *priv = interfacePriv->privPtr;
 
     CsrUint32 pktBulkDataLength;
-    CsrUint8 *pktBulkData;
+    u8 *pktBulkData;
     unsigned long flags;
 
     if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA) {
@@ -1209,7 +1209,7 @@ void uf_send_pkt_to_encrypt(struct work_struct *work)
         pktBulkDataLength = interfacePriv->wapi_unicast_bulk_data.data_length;
 
         if (pktBulkDataLength > 0) {
-                    pktBulkData = (CsrUint8 *)CsrPmemAlloc(pktBulkDataLength);
+                    pktBulkData = (u8 *)CsrPmemAlloc(pktBulkDataLength);
                     CsrMemSet(pktBulkData, 0, pktBulkDataLength);
             } else {
                     unifi_error(priv, "uf_send_pkt_to_encrypt() : invalid buffer\n");
@@ -1218,7 +1218,7 @@ void uf_send_pkt_to_encrypt(struct work_struct *work)
 
         spin_lock_irqsave(&priv->wapi_lock, flags);
         /* Copy over the MA PKT REQ bulk data */
-        CsrMemCpy(pktBulkData, (CsrUint8*)interfacePriv->wapi_unicast_bulk_data.os_data_ptr, pktBulkDataLength);
+        CsrMemCpy(pktBulkData, (u8*)interfacePriv->wapi_unicast_bulk_data.os_data_ptr, pktBulkDataLength);
         /* Free any bulk data buffers allocated for the WAPI Data pkt */
         unifi_net_data_free(priv, &interfacePriv->wapi_unicast_bulk_data);
         interfacePriv->wapi_unicast_bulk_data.net_buf_length = 0;
diff --git a/drivers/staging/csr/unifi_sme.h b/drivers/staging/csr/unifi_sme.h
index 3cbee81f1b0..05de4cde889 100644
--- a/drivers/staging/csr/unifi_sme.h
+++ b/drivers/staging/csr/unifi_sme.h
@@ -87,8 +87,8 @@ typedef struct {
     CsrUint16 appHandle;
     CsrWifiRouterEncapsulation encapsulation;
     CsrUint16 protocol;
-    CsrUint8 oui[3];
-    CsrUint8 in_use;
+    u8 oui[3];
+    u8 in_use;
 } sme_ma_unidata_ind_filter_t;
 
 
@@ -213,7 +213,7 @@ int sme_mgt_mib_set(unifi_priv_t *priv,
 int sme_ap_start(unifi_priv_t *priv,CsrUint16 interface_tag,CsrWifiSmeApConfig_t *ap_config);
 int sme_ap_stop(unifi_priv_t *priv,CsrUint16 interface_tag);
 int sme_ap_config(unifi_priv_t *priv,CsrWifiSmeApMacConfig *ap_mac_config, CsrWifiNmeApConfig *group_security_config);
-int uf_configure_supported_rates(CsrUint8 * supportedRates, CsrUint8 phySupportedBitmap);
+int uf_configure_supported_rates(u8 * supportedRates, u8 phySupportedBitmap);
 #endif
 int unifi_translate_scan(struct net_device *dev,
                          struct iw_request_info *info,
diff --git a/drivers/staging/csr/unifiio.h b/drivers/staging/csr/unifiio.h
index 4ab050bc71c..c1e3f533870 100644
--- a/drivers/staging/csr/unifiio.h
+++ b/drivers/staging/csr/unifiio.h
@@ -212,7 +212,7 @@ typedef struct {
 
 
 
-typedef CsrUint8 unifi_putest_command_t;
+typedef u8 unifi_putest_command_t;
 
 #define UNIFI_PUTEST_START 0
 #define UNIFI_PUTEST_STOP 1
@@ -310,21 +310,21 @@ typedef struct uf_cfg_bcast_packet_filter
 
 typedef struct uf_cfg_ap_config
 {
-    CsrUint8    phySupportedBitmap;
-    CsrUint8    channel;
+    u8    phySupportedBitmap;
+    u8    channel;
     CsrUint16   beaconInterval;
-    CsrUint8    dtimPeriod;
+    u8    dtimPeriod;
     CsrBool     wmmEnabled;
-    CsrUint8    shortSlotTimeEnabled;
+    u8    shortSlotTimeEnabled;
     CsrUint16   groupkeyTimeout;
     CsrBool     strictGtkRekeyEnabled;
     CsrUint16   gmkTimeout;
     CsrUint16   responseTimeout;
-    CsrUint8    retransLimit;
-    CsrUint8    rxStbc;
+    u8    retransLimit;
+    u8    rxStbc;
     CsrBool     rifsModeAllowed;
-    CsrUint8    dualCtsProtection;
-    CsrUint8    ctsProtectionType;
+    u8    dualCtsProtection;
+    u8    ctsProtectionType;
     CsrUint16   maxListenInterval;
 }uf_cfg_ap_config_t;
 
@@ -358,14 +358,14 @@ typedef struct tclas {
 /* WAPI Key */
 typedef struct
 {
-    CsrUint8                          unicastKey;
+    u8                          unicastKey;
     /* If non zero, then unicast key otherwise group key */
-    CsrUint8                          keyIndex;
-    CsrUint8                          keyRsc[16];
-    CsrUint8                          authenticator;
+    u8                          keyIndex;
+    u8                          keyRsc[16];
+    u8                          authenticator;
     /* If non zero, then authenticator otherwise supplicant */
-    CsrUint8                          address[6];
-    CsrUint8                          key[32];
+    u8                          address[6];
+    u8                          key[32];
 } unifiio_wapi_key_t;
 
 /* Values describing XAP memory regions captured by the mini-coredump system */