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>

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. */

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
 {

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);

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);
 
 /*---------------------------------*/

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 */

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;

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
 }

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);
 }

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
 }

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__)

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

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;
 

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
 }

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 */
     {

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)
     {

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

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;
 
 /*******************************************************************************

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

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);

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;
 

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

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

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",

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;
 

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 @@ class ChipHelper
     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)    \

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

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
 }

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;

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;
 

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);

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;

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)
 {

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)

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

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);

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;
 

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
 }

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
 }

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__) \
     { \

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;

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
 

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__);
 

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
 

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)

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;

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);
 

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);

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));
 

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;
 

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__) \
     { \

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);
 

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");

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;

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];

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;

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__ */

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);
 

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,