staging: csr: remove CsrCharString typedef

Use char instead.

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

drivers/staging/csr/csr_formatted_io.c

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

drivers/staging/csr/csr_formatted_io.h

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

drivers/staging/csr/csr_framework_ext.h

@@ -196,7 +196,7 @@ void CsrGlobalMutexUnlock(void);
  *----------------------------------------------------------------------------*/
 CsrResult CsrThreadCreate(void (*threadFunction)(void *pointer), void *pointer,
     u32 stackSize, u16 priority,
-    const CsrCharString *threadName, CsrThreadHandle *threadHandle);
+    const char *threadName, CsrThreadHandle *threadHandle);
 
 /*----------------------------------------------------------------------------*
  *  NAME
@@ -257,7 +257,7 @@ void CsrThreadSleep(u16 sleepTimeInMs);
  *----------------------------------------------------------------------------*/
 #ifdef CSR_MEM_DEBUG
 void *CsrMemAllocDebug(CsrSize size,
-    const CsrCharString *file, u32 line);
+    const char *file, u32 line);
 #define CsrMemAlloc(sz) CsrMemAllocDebug((sz), __FILE__, __LINE__)
 #else
 void *CsrMemAlloc(CsrSize size);
@@ -278,7 +278,7 @@ void *CsrMemAlloc(CsrSize size);
  *----------------------------------------------------------------------------*/
 #ifdef CSR_MEM_DEBUG
 void *CsrMemCallocDebug(CsrSize numberOfElements, CsrSize elementSize,
-    const CsrCharString *file, u32 line);
+    const char *file, u32 line);
 #define CsrMemCalloc(cnt, sz) CsrMemAllocDebug((cnt), (sz), __FILE__, __LINE__)
 #else
 void *CsrMemCalloc(CsrSize numberOfElements, CsrSize elementSize);
@@ -311,7 +311,7 @@ void CsrMemFree(void *pointer);
  *----------------------------------------------------------------------------*/
 #ifdef CSR_MEM_DEBUG
 void *CsrMemAllocDmaDebug(CsrSize size,
-    const CsrCharString *file, u32 line);
+    const char *file, u32 line);
 #define CsrMemAllocDma(sz) CsrMemAllocDmaDebug((sz), __FILE__, __LINE__)
 #else
 void *CsrMemAllocDma(CsrSize size);

drivers/staging/csr/csr_lib.h

@@ -119,7 +119,7 @@ typedef struct
 {
     CsrPrim        type;
     u16      value1;
-    CsrCharString *value2;
+    char *value2;
 } CsrEventCsrUint16CsrCharString;
 
 /*----------------------------------------------------------------------------*
@@ -130,7 +130,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint16CsrCharString
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint16CsrCharString *CsrEventCsrUint16CsrCharString_struct(u16 primtype, u16 msgtype, u16 value1, CsrCharString *value2);
+CsrEventCsrUint16CsrCharString *CsrEventCsrUint16CsrCharString_struct(u16 primtype, u16 msgtype, u16 value1, char *value2);
 
 typedef struct
 {
@@ -169,7 +169,7 @@ typedef struct
 {
     CsrPrim        type;
     u32      value1;
-    CsrCharString *value2;
+    char *value2;
 } CsrEventCsrUint32CsrCharString;
 
 /*----------------------------------------------------------------------------*
@@ -180,7 +180,7 @@ typedef struct
  *      Allocates and fills in a message with the signature CsrEventCsrUint32CsrCharString
  *
  *----------------------------------------------------------------------------*/
-CsrEventCsrUint32CsrCharString *CsrEventCsrUint32CsrCharString_struct(u16 primtype, u16 msgtype, u32 value1, CsrCharString *value2);
+CsrEventCsrUint32CsrCharString *CsrEventCsrUint32CsrCharString_struct(u16 primtype, u16 msgtype, u32 value1, char *value2);
 
 #ifdef __cplusplus
 }

drivers/staging/csr/csr_log.h

@@ -86,7 +86,7 @@ CsrBool CsrLogTaskIsFiltered(CsrSchedQid taskId, CsrLogLevelTask level);
     do {                                                \
         if (!(cond))                                    \
         {                                               \
-            CsrCharString *panic_arg = "[" __FILE__ ":" CSR_LOG_STRINGIFY(__LINE__) "] - " CSR_LOG_STRINGIFY(cond); \
+            char *panic_arg = "[" __FILE__ ":" CSR_LOG_STRINGIFY(__LINE__) "] - " CSR_LOG_STRINGIFY(cond); \
             CsrPanic(CSR_TECH_FW, CSR_PANIC_FW_ASSERTION_FAIL, panic_arg); \
         }                                               \
     } while (0)
@@ -97,13 +97,13 @@ CsrBool CsrLogTaskIsFiltered(CsrSchedQid taskId, CsrLogLevelTask level);
 typedef struct
 {
     u16            primitiveType;
-    const CsrCharString *primitiveName;
+    const char *primitiveName;
     CsrMsgConvMsgEntry  *messageConv; /* Private - do not use */
 } CsrLogPrimitiveInformation;
 
 typedef struct
 {
-    const CsrCharString        *techVer;
+    const char        *techVer;
     u32                   primitiveInfoCount;
     CsrLogPrimitiveInformation *primitiveInfo;
 } CsrLogTechInformation;
@@ -140,9 +140,9 @@ typedef u32 bitmask32_t;
 #endif
 
 /* DEPRECATED - replaced by csr_log_text.h */
-void CsrLogTaskText(const CsrCharString *text,
+void CsrLogTaskText(const char *text,
     u32 line,
-    const CsrCharString *file);
+    const char *file);
 
 #define CSR_LOG_STATE_TRANSITION_MASK_FSM_NAME          (0x001)
 #define CSR_LOG_STATE_TRANSITION_MASK_NEXT_STATE        (0x002)
@@ -155,15 +155,15 @@ void CsrLogTaskText(const CsrCharString *text,
 /* DEPRECATED - replaced by csr_log_text.h */
 void CsrLogStateTransition(bitmask16_t mask,
     u32 identifier,
-    const CsrCharString *fsm_name,
+    const char *fsm_name,
     u32 prev_state,
-    const CsrCharString *prev_state_str,
+    const char *prev_state_str,
     u32 in_event,
-    const CsrCharString *in_event_str,
+    const char *in_event_str,
     u32 next_state,
-    const CsrCharString *next_state_str,
+    const char *next_state_str,
     u32 line,
-    const CsrCharString *file);
+    const char *file);
 
 /*---------------------------------*/
 /*  BSP logging */
@@ -174,7 +174,7 @@ void CsrLogSchedDeinit(u8 thread_id);
 void CsrLogSchedStart(u8 thread_id);
 void CsrLogSchedStop(u8 thread_id);
 
-void CsrLogInitTask(u8 thread_id, CsrSchedQid tskid, const CsrCharString *tskName);
+void CsrLogInitTask(u8 thread_id, CsrSchedQid tskid, const char *tskName);
 void CsrLogDeinitTask(u16 task_id);
 
 void CsrLogActivate(CsrSchedQid tskid);
@@ -184,7 +184,7 @@ void CsrLogDeactivate(CsrSchedQid tskid);
 #define SYNERGY_SERIALIZER_TYPE_SER     (0x001)
 
 void CsrLogMessagePut(u32 line,
-    const CsrCharString *file,
+    const char *file,
     CsrSchedQid src_task_id,
     CsrSchedQid dst_taskid,
     CsrSchedMsgId msg_id,
@@ -199,7 +199,7 @@ void CsrLogMessageGet(CsrSchedQid src_task_id,
     const void *msg);
 
 void CsrLogTimedEventIn(u32 line,
-    const CsrCharString *file,
+    const char *file,
     CsrSchedQid task_id,
     CsrSchedTid tid,
     CsrTime requested_delay,
@@ -213,14 +213,14 @@ void CsrLogTimedEventDone(CsrSchedQid task_id,
     CsrSchedTid tid);
 
 void CsrLogTimedEventCancel(u32 line,
-    const CsrCharString *file,
+    const char *file,
     CsrSchedQid task_id,
     CsrSchedTid tid,
     CsrBool cancel_res);
 
 void CsrLogBgintRegister(u8 thread_id,
     CsrSchedBgint irq,
-    const CsrCharString *callback,
+    const char *callback,
     const void *ptr);
 void CsrLogBgintUnregister(CsrSchedBgint irq);
 void CsrLogBgintSet(CsrSchedBgint irq);
@@ -231,17 +231,17 @@ void CsrLogExceptionStateEvent(u16 prim_type,
     CsrPrim msg_type,
     u16 state,
     u32 line,
-    const CsrCharString *file);
+    const char *file);
 void CsrLogExceptionGeneral(u16 prim_type,
     u16 state,
-    const CsrCharString *text,
+    const char *text,
     u32 line,
-    const CsrCharString *file);
+    const char *file);
 void CsrLogExceptionWarning(u16 prim_type,
     u16 state,
-    const CsrCharString *text,
+    const char *text,
     u32 line,
-    const CsrCharString *file);
+    const char *file);
 
 #ifdef __cplusplus
 }

drivers/staging/csr/csr_log_configure.h

@@ -124,8 +124,8 @@ void CsrLogLevelTextSetTaskSubOrigin(CsrLogTextTaskId taskId, u16 subOrigin, Csr
             sub origin(s).
 
 *******************************************************************************/
-void CsrLogLevelTextSet(const CsrCharString *originName,
-    const CsrCharString *subOriginName,
+void CsrLogLevelTextSet(const char *originName,
+    const char *subOriginName,
     CsrLogLevelText warningLevelMask);
 
 #ifdef __cplusplus

drivers/staging/csr/csr_log_text.h

@@ -20,12 +20,12 @@ extern "C" {
 typedef struct CsrLogSubOrigin
 {
     u16            subOriginNumber;  /* Id of the given SubOrigin */
-    const CsrCharString *subOriginName;    /* Prefix Text for this SubOrigin */
+    const char *subOriginName;    /* Prefix Text for this SubOrigin */
 } CsrLogSubOrigin;
 
 /* Register a task which is going to use the CSR_LOG_TEXT_XXX interface */
 #ifdef CSR_LOG_ENABLE
-void CsrLogTextRegister(CsrLogTextTaskId taskId, const CsrCharString *taskName, u16 subOriginsLength, const CsrLogSubOrigin *subOrigins);
+void CsrLogTextRegister(CsrLogTextTaskId taskId, const char *taskName, u16 subOriginsLength, const CsrLogSubOrigin *subOrigins);
 #else
 #define CsrLogTextRegister(taskId, taskName, subOriginsLength, subOrigins)
 #endif
@@ -33,8 +33,8 @@ void CsrLogTextRegister(CsrLogTextTaskId taskId, const CsrCharString *taskName,
 /* CRITICAL: Conditions that are threatening to the integrity/stability of the
    system as a whole. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_CRITICAL_DISABLE)
-void CsrLogTextCritical(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextCritical(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
+void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
 #define CSR_LOG_TEXT_CRITICAL(taskId_subOrigin_formatString_varargs) CsrLogTextCritical taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_CRITICAL(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_CRITICAL(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_CRITICAL(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferCritical taskId_subOrigin_length_buffer_formatString_varargs
@@ -49,8 +49,8 @@ void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bu
 /* ERROR: Malfunction of a component rendering it unable to operate correctly,
    causing lack of functionality but not loss of system integrity/stability. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_ERROR_DISABLE)
-void CsrLogTextError(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextError(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
+void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
 #define CSR_LOG_TEXT_ERROR(taskId_subOrigin_formatString_varargs) CsrLogTextError taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_ERROR(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_ERROR(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_ERROR(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferError taskId_subOrigin_length_buffer_formatString_varargs
@@ -66,8 +66,8 @@ void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize buffe
    or violations of specifications, where the result of such deviations does not
    lead to malfunction of the component. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_WARNING_DISABLE)
-void CsrLogTextWarning(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextWarning(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
+void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
 #define CSR_LOG_TEXT_WARNING(taskId_subOrigin_formatString_varargs) CsrLogTextWarning taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_WARNING(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_WARNING(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_WARNING(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferWarning taskId_subOrigin_length_buffer_formatString_varargs
@@ -82,8 +82,8 @@ void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize buf
 /* INFO: Important events that may aid in determining the conditions under which
    the more severe conditions are encountered. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_INFO_DISABLE)
-void CsrLogTextInfo(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextInfo(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
+void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
 #define CSR_LOG_TEXT_INFO(taskId_subOrigin_formatString_varargs) CsrLogTextInfo taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_INFO(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_INFO(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_INFO(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferInfo taskId_subOrigin_length_buffer_formatString_varargs
@@ -97,8 +97,8 @@ void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize buffer
 
 /* DEBUG: Similar to INFO, but dedicated to events that occur more frequently. */
 #if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_DEBUG_DISABLE)
-void CsrLogTextDebug(CsrLogTextTaskId taskId, u16 subOrigin, const CsrCharString *formatString, ...);
-void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+void CsrLogTextDebug(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
+void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
 #define CSR_LOG_TEXT_DEBUG(taskId_subOrigin_formatString_varargs) CsrLogTextDebug taskId_subOrigin_formatString_varargs
 #define CSR_LOG_TEXT_CONDITIONAL_DEBUG(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_DEBUG(logtextargs);}}
 #define CSR_LOG_TEXT_BUFFER_DEBUG(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferDebug taskId_subOrigin_length_buffer_formatString_varargs

drivers/staging/csr/csr_msgconv.h

@@ -73,7 +73,7 @@ void CsrMsgConvDeinit(void);
 
 /* SHOULD BE INTERNAL TO FRAMEWORK AKA DEPRECATED */
 
-u32 CsrCharStringSerLen(const CsrCharString *str);
+u32 CsrCharStringSerLen(const char *str);
 u32 CsrUtf8StringSerLen(const u8 *str);
 u32 CsrUtf16StringSerLen(const u16 *str);
 
@@ -82,7 +82,7 @@ void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value);
 void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value);
 void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value);
 void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length);
-void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value);
+void CsrCharStringSer(u8 *buffer, CsrSize *offset, const char *value);
 void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const u8 *value);
 void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const u16 *value);
 void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr);
@@ -92,7 +92,7 @@ void CsrUint8Des(u8 *value, u8 *buffer, CsrSize *offset);
 void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset);
 void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset);
 void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length);
-void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset);
+void CsrCharStringDes(char **value, u8 *buffer, CsrSize *offset);
 void CsrUtf8StringDes(u8 **value, u8 *buffer, CsrSize *offset);
 void CsrUtf16StringDes(u16 **value, u8 *buffer, CsrSize *offset);
 void CsrVoidPtrDes(void **value, u8 *buffer, CsrSize *offset);

drivers/staging/csr/csr_pmem.h

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

drivers/staging/csr/csr_sched.h

@@ -76,7 +76,7 @@ typedef void (*CsrSchedBgintHandler)(void *);
  *----------------------------------------------------------------------------*/
 CsrSchedBgint CsrSchedBgintReg(CsrSchedBgintHandler cb,
     void *context,
-    const CsrCharString *id);
+    const char *id);
 
 /*----------------------------------------------------------------------------*
  *  NAME
@@ -136,7 +136,7 @@ void CsrSchedMessagePutStringLog(CsrSchedQid q,
     u16 mi,
     void *mv,
     u32 line,
-    const CsrCharString *file);
+    const char *file);
 #define CsrSchedMessagePut(q, mi, mv) CsrSchedMessagePutStringLog((q), (mi), (mv), __LINE__, __FILE__)
 #else
 void CsrSchedMessagePut(CsrSchedQid q,
@@ -168,7 +168,7 @@ void CsrSchedMessageBroadcastStringLog(u16 mi,
     void *(*msg_build_func)(void *),
     void *msg_build_ptr,
     u32 line,
-    const CsrCharString *file);
+    const char *file);
 #define CsrSchedMessageBroadcast(mi, fn, ptr) CsrSchedMessageBroadcastStringLog((mi), (fn), (ptr), __LINE__, __FILE__)
 #else
 void CsrSchedMessageBroadcast(u16 mi,
@@ -223,7 +223,7 @@ CsrSchedTid CsrSchedTimerSetStringLog(CsrTime delay,
     u16 fniarg,
     void *fnvarg,
     u32 line,
-    const CsrCharString *file);
+    const char *file);
 #define CsrSchedTimerSet(d, fn, fni, fnv) CsrSchedTimerSetStringLog((d), (fn), (fni), (fnv), __LINE__, __FILE__)
 #else
 CsrSchedTid CsrSchedTimerSet(CsrTime delay,
@@ -249,7 +249,7 @@ CsrBool CsrSchedTimerCancelStringLog(CsrSchedTid eventid,
     u16 *pmi,
     void **pmv,
     u32 line,
-    const CsrCharString *file);
+    const char *file);
 #define CsrSchedTimerCancel(e, pmi, pmv) CsrSchedTimerCancelStringLog((e), (pmi), (pmv), __LINE__, __FILE__)
 #else
 CsrBool CsrSchedTimerCancel(CsrSchedTid eventid,
@@ -279,10 +279,10 @@ CsrSchedQid CsrSchedTaskQueueGet(void);
  *      Return the queue identifier for the currently running queue
  *
  *  RETURNS
- *      CsrCharString - The current task queue identifier, or 0xFFFF if not available.
+ *      char - The current task queue identifier, or 0xFFFF if not available.
  *
  *----------------------------------------------------------------------------*/
-CsrCharString* CsrSchedTaskNameGet(CsrSchedQid );
+char* CsrSchedTaskNameGet(CsrSchedQid );
 
 
 #ifdef __cplusplus

drivers/staging/csr/csr_serialize_primitive_types.c

@@ -48,17 +48,17 @@ void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length)
 }
 EXPORT_SYMBOL_GPL(CsrMemCpyDes);
 
-void CsrCharStringDes(CsrCharString **value, u8 *buffer, CsrSize *offset)
+void CsrCharStringDes(char **value, u8 *buffer, CsrSize *offset)
 {
-    *value = CsrStrDup((CsrCharString *) &buffer[*offset]);
+    *value = CsrStrDup((char *) &buffer[*offset]);
     *offset += CsrStrLen(*value) + 1;
 }
 EXPORT_SYMBOL_GPL(CsrCharStringDes);
 
 void CsrUtf8StringDes(u8 **value, u8 *buffer, CsrSize *offset)
 {
-    *value = (u8 *) CsrStrDup((CsrCharString *) &buffer[*offset]);
-    *offset += CsrStrLen((CsrCharString *) *value) + 1;
+    *value = (u8 *) CsrStrDup((char *) &buffer[*offset]);
+    *offset += CsrStrLen((char *) *value) + 1;
 }
 
 void CsrUtf16StringDes(u16 **value, u8 *buffer, CsrSize *offset)
@@ -120,11 +120,11 @@ void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length
 }
 EXPORT_SYMBOL_GPL(CsrMemCpySer);
 
-void CsrCharStringSer(u8 *buffer, CsrSize *offset, const CsrCharString *value)
+void CsrCharStringSer(u8 *buffer, CsrSize *offset, const char *value)
 {
     if (value)
     {
-        CsrStrCpy(((CsrCharString *) &buffer[*offset]), value);
+        CsrStrCpy(((char *) &buffer[*offset]), value);
         *offset += CsrStrLen(value) + 1;
     }
     else
@@ -136,7 +136,7 @@ EXPORT_SYMBOL_GPL(CsrCharStringSer);
 
 void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const u8 *value)
 {
-    CsrCharStringSer(buffer, offset, (CsrCharString *) value);
+    CsrCharStringSer(buffer, offset, (char *) value);
 }
 
 void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const u16 *value)
@@ -173,7 +173,7 @@ void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr)
     CsrSizeSer(buffer, offset, (CsrSize) ptr);
 }
 
-u32 CsrCharStringSerLen(const CsrCharString *str)
+u32 CsrCharStringSerLen(const char *str)
 {
     if (str)
     {
@@ -189,7 +189,7 @@ u32 CsrUtf8StringSerLen(const u8 *str)
 {
     if (str)
     {
-        return (u32) (CsrStrLen((CsrCharString *) str) + sizeof(*str));
+        return (u32) (CsrStrLen((char *) str) + sizeof(*str));
     }
     else
     {

drivers/staging/csr/csr_types.h

@@ -35,9 +35,6 @@ typedef ptrdiff_t CsrIntptr;    /* intptr_t is not defined in kernel. Use the eq
 /* Boolean */
 typedef u8 CsrBool;
 
-/* String types */
-typedef char CsrCharString;
-
 /*
  * 64-bit integers
  *

drivers/staging/csr/csr_utf16.c

@@ -574,7 +574,7 @@ u16 *CsrUtf82Utf16String(const u8 *utf8String)
     {
         return NULL;
     }
-    sourceLength = CsrStrLen((CsrCharString *) utf8String);
+    sourceLength = CsrStrLen((char *) utf8String);
 
     for (i = 0; i < sourceLength; i++)
     {
@@ -1018,12 +1018,12 @@ u16 *CsrXML2Utf16String(u16 *str)
 
 s32 CsrUtf8StrCmp(const u8 *string1, const u8 *string2)
 {
-    return CsrStrCmp((const CsrCharString *) string1, (const CsrCharString *) string2);
+    return CsrStrCmp((const char *) string1, (const char *) string2);
 }
 
 s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, CsrSize count)
 {
-    return CsrStrNCmp((const CsrCharString *) string1, (const CsrCharString *) string2, count);
+    return CsrStrNCmp((const char *) string1, (const char *) string2, count);
 }
 
 u32 CsrUtf8StringLengthInBytes(const u8 *string)
@@ -1031,14 +1031,14 @@ u32 CsrUtf8StringLengthInBytes(const u8 *string)
     CsrSize length = 0;
     if (string)
     {
-        length = CsrStrLen((const CsrCharString *) string);
+        length = CsrStrLen((const char *) string);
     }
     return (u32) length;
 }
 
 u8 *CsrUtf8StrCpy(u8 *target, const u8 *source)
 {
-    return (u8 *) CsrStrCpy((CsrCharString *) target, (const CsrCharString *) source);
+    return (u8 *) CsrStrCpy((char *) target, (const char *) source);
 }
 
 u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count)
@@ -1072,12 +1072,12 @@ u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count)
 
 u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count)
 {
-    return (u8 *) CsrStrNCpy((CsrCharString *) target, (const CsrCharString *) source, count);
+    return (u8 *) CsrStrNCpy((char *) target, (const char *) source, count);
 }
 
 u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, CsrSize count)
 {
-    CsrStrNCpy((CsrCharString *) target, (const CsrCharString *) source, count);
+    CsrStrNCpy((char *) target, (const char *) source, count);
     if (target[count - 1] != '\0')
     {
         CsrUtf8StrTruncate(target, count - 1);
@@ -1087,7 +1087,7 @@ u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, CsrSize count)
 
 u8 *CsrUtf8StrDup(const u8 *source)
 {
-    return (u8 *) CsrStrDup((const CsrCharString *) source);
+    return (u8 *) CsrStrDup((const char *) source);
 }
 
 u8 *CsrUtf8StringConcatenateTexts(const u8 *inputText1, const u8 *inputText2, const u8 *inputText3, const u8 *inputText4)

drivers/staging/csr/csr_util.c

@@ -53,7 +53,7 @@ u8 CsrBitCountDense(u32 n)
 /*------------------------------------------------------------------*/
 /* Base conversion */
 /*------------------------------------------------------------------*/
-CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue)
+CsrBool CsrHexStrToUint8(const char *string, u8 *returnValue)
 {
     u16 currentIndex = 0;
     *returnValue = 0;
@@ -77,7 +77,7 @@ CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue)
     return FALSE;
 }
 
-CsrBool CsrHexStrToUint16(const CsrCharString *string, u16 *returnValue)
+CsrBool CsrHexStrToUint16(const char *string, u16 *returnValue)
 {
     u16 currentIndex = 0;
     *returnValue = 0;
@@ -101,7 +101,7 @@ CsrBool CsrHexStrToUint16(const CsrCharString *string, u16 *returnValue)
     return FALSE;
 }
 
-CsrBool CsrHexStrToUint32(const CsrCharString *string, u32 *returnValue)
+CsrBool CsrHexStrToUint32(const char *string, u32 *returnValue)
 {
     u16 currentIndex = 0;
     *returnValue = 0;
@@ -145,11 +145,11 @@ u32 CsrPow(u32 base, u32 exponent)
 
 /* Convert signed 32 bit (or less) integer to string */
 #define I2B10_MAX 12
-void CsrIntToBase10(s32 number, CsrCharString *str)
+void CsrIntToBase10(s32 number, char *str)
 {
     s32 digit;
     u8 index;
-    CsrCharString res[I2B10_MAX];
+    char res[I2B10_MAX];
     CsrBool foundDigit = FALSE;
 
     for (digit = 0; digit < I2B10_MAX; digit++)
@@ -190,7 +190,7 @@ void CsrIntToBase10(s32 number, CsrCharString *str)
     CsrStrCpy(str, res);
 }
 
-void CsrUInt16ToHex(u16 number, CsrCharString *str)
+void CsrUInt16ToHex(u16 number, char *str)
 {
     u16 index;
     u16 currentValue;
@@ -204,7 +204,7 @@ void CsrUInt16ToHex(u16 number, CsrCharString *str)
     str[4] = '\0';
 }
 
-void CsrUInt32ToHex(u32 number, CsrCharString *str)
+void CsrUInt32ToHex(u32 number, char *str)
 {
     u16 index;
     u32 currentValue;
@@ -261,61 +261,61 @@ void *CsrMemDup(const void *buf1, CsrSize count)
 #endif
 
 #ifndef CSR_USE_STDC_LIB
-CsrCharString *CsrStrCpy(CsrCharString *dest, const CsrCharString *src)
+char *CsrStrCpy(char *dest, const char *src)
 {
     return strcpy(dest, src);
 }
 
-CsrCharString *CsrStrNCpy(CsrCharString *dest, const CsrCharString *src, CsrSize count)
+char *CsrStrNCpy(char *dest, const char *src, CsrSize count)
 {
     return strncpy(dest, src, count);
 }
 
-CsrCharString *CsrStrCat(CsrCharString *dest, const CsrCharString *src)
+char *CsrStrCat(char *dest, const char *src)
 {
     return strcat(dest, src);
 }
 
-CsrCharString *CsrStrNCat(CsrCharString *dest, const CsrCharString *src, CsrSize count)
+char *CsrStrNCat(char *dest, const char *src, CsrSize count)
 {
     return strncat(dest, src, count);
 }
 
-CsrCharString *CsrStrStr(const CsrCharString *string1, const CsrCharString *string2)
+char *CsrStrStr(const char *string1, const char *string2)
 {
     return strstr(string1, string2);
 }
 
-CsrSize CsrStrLen(const CsrCharString *string)
+CsrSize CsrStrLen(const char *string)
 {
     return strlen(string);
 }
 EXPORT_SYMBOL_GPL(CsrStrLen);
 
-s32 CsrStrCmp(const CsrCharString *string1, const CsrCharString *string2)
+s32 CsrStrCmp(const char *string1, const char *string2)
 {
     return strcmp(string1, string2);
 }
 
-s32 CsrStrNCmp(const CsrCharString *string1, const CsrCharString *string2, CsrSize count)
+s32 CsrStrNCmp(const char *string1, const char *string2, CsrSize count)
 {
     return strncmp(string1, string2, count);
 }
 
-CsrCharString *CsrStrChr(const CsrCharString *string, CsrCharString c)
+char *CsrStrChr(const char *string, char c)
 {
     return strchr(string, c);
 }
 #endif
 
-s32 CsrVsnprintf(CsrCharString *string, CsrSize count, const CsrCharString *format, va_list args)
+s32 CsrVsnprintf(char *string, CsrSize count, const char *format, va_list args)
 {
     return vsnprintf(string, count, format, args);
 }
 EXPORT_SYMBOL_GPL(CsrVsnprintf);
 
-CsrCharString *CsrStrNCpyZero(CsrCharString *dest,
-    const CsrCharString *src,
+char *CsrStrNCpyZero(char *dest,
+    const char *src,
     CsrSize count)
 {
     CsrStrNCpy(dest, src, count - 1);
@@ -324,7 +324,7 @@ CsrCharString *CsrStrNCpyZero(CsrCharString *dest,
 }
 
 /* Convert string with base 10 to integer */
-u32 CsrStrToInt(const CsrCharString *str)
+u32 CsrStrToInt(const char *str)
 {
     s16 i;
     u32 res;
@@ -347,9 +347,9 @@ u32 CsrStrToInt(const CsrCharString *str)
     return res;
 }
 
-CsrCharString *CsrStrDup(const CsrCharString *string)
+char *CsrStrDup(const char *string)
 {
-    CsrCharString *copy;
+    char *copy;
     u32 len;
 
     copy = NULL;
@@ -362,8 +362,8 @@ CsrCharString *CsrStrDup(const CsrCharString *string)
     return copy;
 }
 
-int CsrStrNICmp(const CsrCharString *string1,
-    const CsrCharString *string2,
+int CsrStrNICmp(const char *string1,
+    const char *string2,
     CsrSize count)
 {
     u32 index;
@@ -391,10 +391,10 @@ int CsrStrNICmp(const CsrCharString *string1,
     return returnValue;
 }
 
-const CsrCharString *CsrGetBaseName(const CsrCharString *file)
+const char *CsrGetBaseName(const char *file)
 {
-    const CsrCharString *pch;
-    static const CsrCharString dotDir[] = ".";
+    const char *pch;
+    static const char dotDir[] = ".";
 
     if (!file)
     {

drivers/staging/csr/csr_util.h

@@ -26,13 +26,13 @@ u8 CsrBitCountDense(u32 n);
 /*------------------------------------------------------------------*/
 /* Base conversion */
 /*------------------------------------------------------------------*/
-CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue);
-CsrBool CsrHexStrToUint16(const CsrCharString *string, u16 *returnValue);
-CsrBool CsrHexStrToUint32(const CsrCharString *string, u32 *returnValue);
+CsrBool CsrHexStrToUint8(const char *string, u8 *returnValue);
+CsrBool CsrHexStrToUint16(const char *string, u16 *returnValue);
+CsrBool CsrHexStrToUint32(const char *string, u32 *returnValue);
 u32 CsrPow(u32 base, u32 exponent);
-void CsrIntToBase10(s32 number, CsrCharString *str);
-void CsrUInt16ToHex(u16 number, CsrCharString *str);
-void CsrUInt32ToHex(u32 number, CsrCharString *str);
+void CsrIntToBase10(s32 number, char *str);
+void CsrUInt16ToHex(u16 number, char *str);
+void CsrUInt32ToHex(u32 number, char *str);
 
 /*------------------------------------------------------------------*/
 /* Standard C Library functions */
@@ -54,33 +54,33 @@ void CsrUInt32ToHex(u32 number, CsrCharString *str);
 #else /* !CSR_USE_STDC_LIB */
 void *CsrMemCpy(void *dest, const void *src, CsrSize count);
 void *CsrMemMove(void *dest, const void *src, CsrSize count);
-CsrCharString *CsrStrCpy(CsrCharString *dest, const CsrCharString *src);
-CsrCharString *CsrStrNCpy(CsrCharString *dest, const CsrCharString *src, CsrSize count);
-CsrCharString *CsrStrCat(CsrCharString *dest, const CsrCharString *src);
-CsrCharString *CsrStrNCat(CsrCharString *dest, const CsrCharString *src, CsrSize count);
+char *CsrStrCpy(char *dest, const char *src);
+char *CsrStrNCpy(char *dest, const char *src, CsrSize count);
+char *CsrStrCat(char *dest, const char *src);
+char *CsrStrNCat(char *dest, const char *src, CsrSize count);
 s32 CsrMemCmp(const void *buf1, const void *buf2, CsrSize count);
-s32 CsrStrCmp(const CsrCharString *string1, const CsrCharString *string2);
-s32 CsrStrNCmp(const CsrCharString *string1, const CsrCharString *string2, CsrSize count);
-CsrCharString *CsrStrChr(const CsrCharString *string, CsrCharString c);
-CsrCharString *CsrStrStr(const CsrCharString *string1, const CsrCharString *string2);
+s32 CsrStrCmp(const char *string1, const char *string2);
+s32 CsrStrNCmp(const char *string1, const char *string2, CsrSize count);
+char *CsrStrChr(const char *string, char c);
+char *CsrStrStr(const char *string1, const char *string2);
 void *CsrMemSet(void *dest, u8 c, CsrSize count);
-CsrSize CsrStrLen(const CsrCharString *string);
+CsrSize CsrStrLen(const char *string);
 #endif /* !CSR_USE_STDC_LIB */
-s32 CsrVsnprintf(CsrCharString *string, CsrSize count, const CsrCharString *format, va_list args);
+s32 CsrVsnprintf(char *string, CsrSize count, const char *format, va_list args);
 
 /*------------------------------------------------------------------*/
 /* Non-standard utility functions */
 /*------------------------------------------------------------------*/
 void *CsrMemDup(const void *buf1, CsrSize count);
-int CsrStrNICmp(const CsrCharString *string1, const CsrCharString *string2, CsrSize count);
-CsrCharString *CsrStrDup(const CsrCharString *string);
-u32 CsrStrToInt(const CsrCharString *string);
-CsrCharString *CsrStrNCpyZero(CsrCharString *dest, const CsrCharString *src, CsrSize count);
+int CsrStrNICmp(const char *string1, const char *string2, CsrSize count);
+char *CsrStrDup(const char *string);
+u32 CsrStrToInt(const char *string);
+char *CsrStrNCpyZero(char *dest, const char *src, CsrSize count);
 
 /*------------------------------------------------------------------*/
 /* Filename */
 /*------------------------------------------------------------------*/
-const CsrCharString *CsrGetBaseName(const CsrCharString *file);
+const char *CsrGetBaseName(const char *file);
 
 /*------------------------------------------------------------------*/
 /* Misc */

drivers/staging/csr/csr_wifi_fsm_types.h

@@ -205,7 +205,7 @@ typedef struct
     u32                 eventid;
     CsrWifiFsmTransitionFnPtr transition;
 #ifdef CSR_LOG_ENABLE
-    const CsrCharString *transitionName;
+    const char *transitionName;
 #endif
 } CsrWifiFsmEventEntry;
 
@@ -224,7 +224,7 @@ typedef struct
     const CsrWifiFsmEventEntry *eventEntryArray; /* array of transition function pointers for state */
 #ifdef CSR_LOG_ENABLE
     u16            stateNumber;
-    const CsrCharString *stateName;
+    const char *stateName;
 #endif
 } CsrWifiFsmTableEntry;
 
@@ -252,7 +252,7 @@ typedef struct
  */
 typedef struct
 {
-    const CsrCharString                    *processName;
+    const char                    *processName;
     const u32                         processId;
     const CsrWifiFsmTransitionFunctionTable transitionTable;
     const CsrWifiFsmTableEntry              unhandledTransitions;
@@ -278,7 +278,7 @@ typedef struct
     CsrWifiFsmTransitionFnPtr transitionFn;
     u16                 transitionCount; /* number consecutive of times this transition was seen */
 #ifdef CSR_LOG_ENABLE
-    const CsrCharString *transitionName;
+    const char *transitionName;
 #endif
 } CsrWifiFsmTransitionRecord;
 

drivers/staging/csr/csr_wifi_hip_card.h

@@ -110,9 +110,9 @@ CsrResult unifi_coredump_handle_request(card_t *card);
 
 CsrResult ConvertCsrSdioToCsrHipResult(card_t *card, CsrResult csrResult);
 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
-void unifi_debug_log_to_buf(const CsrCharString *fmt, ...);
-void unifi_debug_string_to_buf(const CsrCharString *str);
-void unifi_debug_hex_to_buf(const CsrCharString *buff, u16 length);
+void unifi_debug_log_to_buf(const char *fmt, ...);
+void unifi_debug_string_to_buf(const char *str);
+void unifi_debug_hex_to_buf(const char *buff, u16 length);
 #endif
 
 

drivers/staging/csr/csr_wifi_hip_card_sdio.c

@@ -3900,7 +3900,7 @@ CsrResult unifi_set_host_state(card_t *card, enum unifi_host_state state)
 {
     CsrResult r = CSR_RESULT_SUCCESS;
     CsrResult csrResult;
-    static const CsrCharString *const states[] = {
+    static const char *const states[] = {
         "AWAKE", "DROWSY", "TORPID"
     };
     static const u8 state_csr_host_wakeup[] = {

drivers/staging/csr/csr_wifi_hip_card_sdio.h

@@ -269,7 +269,7 @@ typedef struct
     u16 q_wr_ptr;
     u16 q_rd_ptr;
 
-    CsrCharString name[UNIFI_QUEUE_NAME_MAX_LENGTH];
+    char name[UNIFI_QUEUE_NAME_MAX_LENGTH];
 } q_t;
 
 
@@ -412,7 +412,7 @@ struct card
 
     /* Info read from Symbol Table during probe */
     u32     build_id;
-    CsrCharString build_id_string[128];
+    char build_id_string[128];
 
     /* Retrieve from SDIO driver. */
     u16 chip_id;

drivers/staging/csr/csr_wifi_hip_card_sdio_intr.c

@@ -81,11 +81,11 @@ s16 dump_fh_buf = 0;
  */
 
 #define UNIFI_DEBUG_GBUFFER_SIZE       8192
-static CsrCharString unifi_debug_output[UNIFI_DEBUG_GBUFFER_SIZE];
-static CsrCharString *unifi_dbgbuf_ptr = unifi_debug_output;
-static CsrCharString *unifi_dbgbuf_start = unifi_debug_output;
+static char unifi_debug_output[UNIFI_DEBUG_GBUFFER_SIZE];
+static char *unifi_dbgbuf_ptr = unifi_debug_output;
+static char *unifi_dbgbuf_start = unifi_debug_output;
 
-static void append_char(CsrCharString c)
+static void append_char(char c)
 {
     /* write char and advance pointer */
     *unifi_dbgbuf_ptr++ = c;
@@ -97,9 +97,9 @@ static void append_char(CsrCharString c)
 } /* append_char() */
 
 
-void unifi_debug_string_to_buf(const CsrCharString *str)
+void unifi_debug_string_to_buf(const char *str)
 {
-    const CsrCharString *p = str;
+    const char *p = str;
     while (*p)
     {
         append_char(*p);
@@ -114,10 +114,10 @@ void unifi_debug_string_to_buf(const CsrCharString *str)
 }
 
 
-void unifi_debug_log_to_buf(const CsrCharString *fmt, ...)
+void unifi_debug_log_to_buf(const char *fmt, ...)
 {
 #define DEBUG_BUFFER_SIZE       80
-    static CsrCharString s[DEBUG_BUFFER_SIZE];
+    static char s[DEBUG_BUFFER_SIZE];
     va_list args;
 
     va_start(args, fmt);
@@ -143,9 +143,9 @@ void unifi_debug_log_to_buf(const CsrCharString *fmt, ...)
  *
  * ---------------------------------------------------------------------------
  */
-void unifi_debug_hex_to_buf(const CsrCharString *buff, u16 length)
+void unifi_debug_hex_to_buf(const char *buff, u16 length)
 {
-    CsrCharString s[5];
+    char s[5];
     u16 i;
 
     for (i = 0; i < length; i = i + 2)

drivers/staging/csr/csr_wifi_hip_chiphelper.h

@@ -196,8 +196,8 @@ ChipDescript* ChipHelper_GetVersionBlueCore(enum chip_helper_bluecore_age age,
    parameter is the name of the parameter. The bodies of these
    functions are hand written. */
 #define CHIP_HELPER_LIST(m)                                             \
-    CHIP_HELPER_DEF0(m, (const CsrCharString *, FriendlyName, friendly_name))     \
-    CHIP_HELPER_DEF0(m, (const CsrCharString *, MarketingName, marketing_name))  \
+    CHIP_HELPER_DEF0(m, (const char *, FriendlyName, friendly_name))     \
+    CHIP_HELPER_DEF0(m, (const char *, MarketingName, marketing_name))  \
     CHIP_HELPER_DEF0(m, (u16, DBG_EMU_CMD, regs->dbg_emu_cmd))       \
     CHIP_HELPER_DEF0(m, (u16, DBG_HOST_PROC_SELECT, regs->host.dbg_proc_select)) \
     CHIP_HELPER_DEF0(m, (u16, DBG_HOST_STOP_STATUS, regs->host.dbg_stop_status)) \

drivers/staging/csr/csr_wifi_hip_chiphelper_private.h

@@ -151,9 +151,9 @@ struct chip_device_desc_t
     struct chip_version_t chip_version;
 
     /* This is a text string that a human might find useful (BC02, UF105x) */
-    const CsrCharString *friendly_name;
+    const char *friendly_name;
     /* This is what we show to customers */
-    const CsrCharString *marketing_name;
+    const char *marketing_name;
 
     /* Initialisation values to write following a reset */
     struct val_array_t init;

drivers/staging/csr/csr_wifi_hip_udi.c

@@ -41,9 +41,9 @@
  *      None.
  * ---------------------------------------------------------------------------
  */
-s32 unifi_print_status(card_t *card, CsrCharString *str, s32 *remain)
+s32 unifi_print_status(card_t *card, char *str, s32 *remain)
 {
-    CsrCharString *p = str;
+    char *p = str;
     sdio_config_data_t *cfg;
     u16 i, n;
     s32 remaining = *remain;
@@ -51,7 +51,7 @@ s32 unifi_print_status(card_t *card, CsrCharString *str, s32 *remain)
 #ifdef CSR_UNSAFE_SDIO_ACCESS
     s32 iostate;
     CsrResult r;
-    static const CsrCharString *const states[] = {
+    static const char *const states[] = {
         "AWAKE", "DROWSY", "TORPID"
     };
     #define SHARED_READ_RETRY_LIMIT 10

drivers/staging/csr/csr_wifi_hip_unifi.h

@@ -859,13 +859,13 @@ void unifi_request_max_sdio_clock(card_t *card);
 
 
 /* Functions to lookup bulk data command names. */
-const CsrCharString* lookup_bulkcmd_name(u16 id);
+const char* lookup_bulkcmd_name(u16 id);
 
 /* Function to log HIP's global debug buffer */
 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
 void unifi_debug_buf_dump(void);
-void unifi_debug_log_to_buf(const CsrCharString *fmt, ...);
-void unifi_debug_hex_to_buf(const CsrCharString *buff, u16 length);
+void unifi_debug_log_to_buf(const char *fmt, ...);
+void unifi_debug_hex_to_buf(const char *buff, u16 length);
 #endif
 
 /* Mini-coredump utility functions */

drivers/staging/csr/csr_wifi_hip_unifi_signal_names.c

@@ -13,7 +13,7 @@
 struct sig_name
 {
     s16             id;
-    const CsrCharString *name;
+    const char *name;
 };
 
 static const struct sig_name Unifi_bulkcmd_names[] = {
@@ -29,7 +29,7 @@ static const struct sig_name Unifi_bulkcmd_names[] = {
     {  15, "Padding" }
 };
 
-const CsrCharString* lookup_bulkcmd_name(u16 id)
+const char* lookup_bulkcmd_name(u16 id)
 {
     if (id < 9)
     {

drivers/staging/csr/csr_wifi_hip_unifi_udi.h

@@ -51,7 +51,7 @@ CsrResult unifi_remove_udi_hook(card_t *card, udi_func_t udi_fn);
  * This is used in the linux /proc interface and might be useful
  * in other systems.
  */
-s32 unifi_print_status(card_t *card, CsrCharString *str, s32 *remain);
+s32 unifi_print_status(card_t *card, char *str, s32 *remain);
 
 #define UNIFI_SNPRINTF_RET(buf_p, remain, written)                  \
     do {                                                            \

drivers/staging/csr/csr_wifi_hip_xbv.c

@@ -52,7 +52,7 @@ typedef struct
 /* Struct to represent a TLV field */
 typedef struct
 {
-    CsrCharString t_name[4];
+    char t_name[4];
     u32     t_len;
 } tag_t;
 
@@ -105,9 +105,9 @@ static u32 write_uint32(void *buf, const u32 offset,
 static u32 write_bytes(void *buf, const u32 offset,
                              const u8 *data, const u32 len);
 static u32 write_tag(void *buf, const u32 offset,
-                           const CsrCharString *tag_str);
+                           const char *tag_str);
 static u32 write_chunk(void *buf, const u32 offset,
-                             const CsrCharString *tag_str,
+                             const char *tag_str,
                              const u32 payload_len);
 static u16 calc_checksum(void *buf, const u32 offset,
                                const u32 bytes_len);
@@ -227,7 +227,7 @@ CsrResult xbv1_parse(card_t *card, fwreadfn_t readfn, void *dlpriv, xbv1_t *fwin
         }
         else if (TAG_EQ(tag.t_name, "LIST"))
         {
-            CsrCharString name[4];
+            char name[4];
             u32 list_end;
 
             list_end = ct.ioffset + tag.t_len;
@@ -598,7 +598,7 @@ static u32 write_bytes(void *buf, const u32 offset, const u8 *data, const u32 le
 }
 
 
-static u32 write_tag(void *buf, const u32 offset, const CsrCharString *tag_str)
+static u32 write_tag(void *buf, const u32 offset, const char *tag_str)
 {
     u8 *dst = (u8 *)buf + offset;
     CsrMemCpy(dst, tag_str, 4);
@@ -606,7 +606,7 @@ static u32 write_tag(void *buf, const u32 offset, const CsrCharString *tag_str)
 }
 
 
-static u32 write_chunk(void *buf, const u32 offset, const CsrCharString *tag_str, const u32 payload_len)
+static u32 write_chunk(void *buf, const u32 offset, const char *tag_str, const u32 payload_len)
 {
     u32 written = 0;
     written += write_tag(buf, offset, tag_str);
@@ -681,9 +681,9 @@ static u32 write_xbv_header(void *buf, const u32 offset, const u32 file_payload_
      * contents of the file, excluding the 8 byte size of the XBV1 header itself
      * (The added 6 bytes thus accounts for the size of the VERF)
      */
-    written += write_chunk(buf, offset + written, (CsrCharString *)"XBV1", file_payload_length + 6);
+    written += write_chunk(buf, offset + written, (char *)"XBV1", file_payload_length + 6);
 
-    written += write_chunk(buf, offset + written, (CsrCharString *)"VERF", 2);
+    written += write_chunk(buf, offset + written, (char *)"VERF", 2);
     written += write_uint16(buf,  offset + written, 0);      /* File version */
 
     return written;
@@ -695,10 +695,10 @@ static u32 write_ptch_header(void *buf, const u32 offset, const u32 fw_id)
     u32 written = 0;
 
     /* LIST is written with a zero length, to be updated later */
-    written += write_chunk(buf, offset + written, (CsrCharString *)"LIST", 0);
-    written += write_tag(buf, offset + written, (CsrCharString *)"PTCH");        /* List type */
+    written += write_chunk(buf, offset + written, (char *)"LIST", 0);
+    written += write_tag(buf, offset + written, (char *)"PTCH");        /* List type */
 
-    written += write_chunk(buf, offset + written, (CsrCharString *)"FWID", 4);
+    written += write_chunk(buf, offset + written, (char *)"FWID", 4);
     written += write_uint32(buf, offset + written, fw_id);
 
 
@@ -761,7 +761,7 @@ static u32 write_fwdl_to_ptdl(void *buf, const u32 offset, fwreadfn_t readfn,
         sec_len = sec_data_len + PTDL_HDR_SIZE;
 
         /* Write PTDL header + entire PTDL size */
-        written += write_chunk(buf, offset + written, (CsrCharString *)"PTDL", sec_len);
+        written += write_chunk(buf, offset + written, (char *)"PTDL", sec_len);
         /* bug digest implies 4 bytes of padding here, but that seems wrong */
 
         /* Checksum starts here */
@@ -820,7 +820,7 @@ static u32 write_reset_ptdl(void *buf, const u32 offset, const xbv1_t *fwinfo, u
     sec_len = SEC_CMD_LEN + PTDL_VEC_HDR_SIZE; /* Total section byte length */
 
     /* Write PTDL header + entire PTDL size */
-    written += write_chunk(buf, offset + written, (CsrCharString *)"PTDL", sec_len);
+    written += write_chunk(buf, offset + written, (char *)"PTDL", sec_len);
 
     /* Checksum starts here */
     csum_start_offs = offset + written;

drivers/staging/csr/csr_wifi_nme_ap_converter_init.c

@@ -76,7 +76,7 @@ void CsrWifiNmeApConverterInit(void)
 #ifdef CSR_LOG_ENABLE
 static const CsrLogPrimitiveInformation csrwifinmeap_conv_info = {
     CSR_WIFI_NME_AP_PRIM,
-    (CsrCharString *)"CSR_WIFI_NME_AP_PRIM",
+    (char *)"CSR_WIFI_NME_AP_PRIM",
     csrwifinmeap_conv_lut
 };
 const CsrLogPrimitiveInformation* CsrWifiNmeApTechInfoGet(void)

drivers/staging/csr/csr_wifi_nme_ap_lib.h

@@ -63,20 +63,20 @@ void CsrWifiNmeApFreeDownstreamMessageContents(u16 eventClass, void *message);
 /*----------------------------------------------------------------------------*
  * Enum to string functions
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiNmeApPersCredentialTypeToString(CsrWifiNmeApPersCredentialType value);
+const char* CsrWifiNmeApPersCredentialTypeToString(CsrWifiNmeApPersCredentialType value);
 
 
 /*----------------------------------------------------------------------------*
  * CsrPrim Type toString function.
  * Converts a message type to the String name of the Message
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiNmeApPrimTypeToString(CsrPrim msgType);
+const char* CsrWifiNmeApPrimTypeToString(CsrPrim msgType);
 
 /*----------------------------------------------------------------------------*
  * Lookup arrays for PrimType name Strings
  *----------------------------------------------------------------------------*/
-extern const CsrCharString *CsrWifiNmeApUpstreamPrimNames[CSR_WIFI_NME_AP_PRIM_UPSTREAM_COUNT];
-extern const CsrCharString *CsrWifiNmeApDownstreamPrimNames[CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT];
+extern const char *CsrWifiNmeApUpstreamPrimNames[CSR_WIFI_NME_AP_PRIM_UPSTREAM_COUNT];
+extern const char *CsrWifiNmeApDownstreamPrimNames[CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT];
 
 /*******************************************************************************
 

drivers/staging/csr/csr_wifi_nme_ap_serialize.c

@@ -324,7 +324,7 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
                     break;
                 case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
                     bufferSize += 2;                                                                                                                                                                                                                      /* u16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode */
-                    bufferSize += (primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase?CsrStrLen(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase) : 0) + 1; /* CsrCharString* primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase (0 byte len + 1 for NULL Term) */
+                    bufferSize += (primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase?CsrStrLen(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase) : 0) + 1; /* char* primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase (0 byte len + 1 for NULL Term) */
                     break;
                 default:
                     break;

drivers/staging/csr/csr_wifi_nme_lib.h

@@ -60,32 +60,32 @@ void CsrWifiNmeFreeDownstreamMessageContents(u16 eventClass, void *message);
 /*----------------------------------------------------------------------------*
  * Enum to string functions
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiNmeAuthModeToString(CsrWifiNmeAuthMode value);
-const CsrCharString* CsrWifiNmeBssTypeToString(CsrWifiNmeBssType value);
-const CsrCharString* CsrWifiNmeCcxOptionsMaskToString(CsrWifiNmeCcxOptionsMask value);
-const CsrCharString* CsrWifiNmeConfigActionToString(CsrWifiNmeConfigAction value);
-const CsrCharString* CsrWifiNmeConnectionStatusToString(CsrWifiNmeConnectionStatus value);
-const CsrCharString* CsrWifiNmeCredentialTypeToString(CsrWifiNmeCredentialType value);
-const CsrCharString* CsrWifiNmeEapMethodToString(CsrWifiNmeEapMethod value);
-const CsrCharString* CsrWifiNmeEncryptionToString(CsrWifiNmeEncryption value);
-const CsrCharString* CsrWifiNmeIndicationsToString(CsrWifiNmeIndications value);
-const CsrCharString* CsrWifiNmeSecErrorToString(CsrWifiNmeSecError value);
-const CsrCharString* CsrWifiNmeSimCardTypeToString(CsrWifiNmeSimCardType value);
-const CsrCharString* CsrWifiNmeUmtsAuthResultToString(CsrWifiNmeUmtsAuthResult value);
-const CsrCharString* CsrWifiNmeWmmQosInfoToString(CsrWifiNmeWmmQosInfo value);
+const char* CsrWifiNmeAuthModeToString(CsrWifiNmeAuthMode value);
+const char* CsrWifiNmeBssTypeToString(CsrWifiNmeBssType value);
+const char* CsrWifiNmeCcxOptionsMaskToString(CsrWifiNmeCcxOptionsMask value);
+const char* CsrWifiNmeConfigActionToString(CsrWifiNmeConfigAction value);
+const char* CsrWifiNmeConnectionStatusToString(CsrWifiNmeConnectionStatus value);
+const char* CsrWifiNmeCredentialTypeToString(CsrWifiNmeCredentialType value);
+const char* CsrWifiNmeEapMethodToString(CsrWifiNmeEapMethod value);
+const char* CsrWifiNmeEncryptionToString(CsrWifiNmeEncryption value);
+const char* CsrWifiNmeIndicationsToString(CsrWifiNmeIndications value);
+const char* CsrWifiNmeSecErrorToString(CsrWifiNmeSecError value);
+const char* CsrWifiNmeSimCardTypeToString(CsrWifiNmeSimCardType value);
+const char* CsrWifiNmeUmtsAuthResultToString(CsrWifiNmeUmtsAuthResult value);
+const char* CsrWifiNmeWmmQosInfoToString(CsrWifiNmeWmmQosInfo value);
 
 
 /*----------------------------------------------------------------------------*
  * CsrPrim Type toString function.
  * Converts a message type to the String name of the Message
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiNmePrimTypeToString(CsrPrim msgType);
+const char* CsrWifiNmePrimTypeToString(CsrPrim msgType);
 
 /*----------------------------------------------------------------------------*
  * Lookup arrays for PrimType name Strings
  *----------------------------------------------------------------------------*/
-extern const CsrCharString *CsrWifiNmeUpstreamPrimNames[CSR_WIFI_NME_PRIM_UPSTREAM_COUNT];
-extern const CsrCharString *CsrWifiNmeDownstreamPrimNames[CSR_WIFI_NME_PRIM_DOWNSTREAM_COUNT];
+extern const char *CsrWifiNmeUpstreamPrimNames[CSR_WIFI_NME_PRIM_UPSTREAM_COUNT];
+extern const char *CsrWifiNmeDownstreamPrimNames[CSR_WIFI_NME_PRIM_DOWNSTREAM_COUNT];
 
 /*******************************************************************************
 

drivers/staging/csr/csr_wifi_nme_prim.h

@@ -547,7 +547,7 @@ typedef struct
 typedef struct
 {
     u16      encryptionMode;
-    CsrCharString *passphrase;
+    char *passphrase;
 } CsrWifiNmePassphrase;
 
 /*******************************************************************************
@@ -708,22 +708,22 @@ typedef struct
     CsrWifiNmeEapMethodMask  eapMethodMask;
     CsrWifiSmeAuthModeMask   authMode;
     CsrWifiNmeEncryptionMask encryptionMode;
-    CsrCharString           *userName;
-    CsrCharString           *userPassword;
-    CsrCharString           *authServerUserIdentity;
+    char           *userName;
+    char           *userPassword;
+    char           *authServerUserIdentity;
     u32                clientCertificateLength;
     u8                *clientCertificate;
     u32                certificateAuthorityCertificateLength;
     u8                *certificateAuthorityCertificate;
     u16                privateKeyLength;
     u8                *privateKey;
-    CsrCharString           *privateKeyPassword;
+    char           *privateKeyPassword;
     u32                sessionLength;
     u8                *session;
     CsrBool                  allowPacProvisioning;
     u32                pacLength;
     u8                *pac;
-    CsrCharString           *pacPassword;
+    char           *pacPassword;
 } CsrWifiNmeEapCredentials;
 
 /*******************************************************************************
@@ -1153,7 +1153,7 @@ typedef struct
 {
     CsrWifiFsmEvent       common;
     CsrResult             status;
-    CsrCharString        *imsi;
+    char        *imsi;
     CsrWifiNmeSimCardType cardType;
 } CsrWifiNmeSimImsiGetRes;
 

drivers/staging/csr/csr_wifi_router_converter_init.c

@@ -70,7 +70,7 @@ void CsrWifiRouterConverterInit(void)
 #ifdef CSR_LOG_ENABLE
 static const CsrLogPrimitiveInformation csrwifirouter_conv_info = {
     CSR_WIFI_ROUTER_PRIM,
-    (CsrCharString *)"CSR_WIFI_ROUTER_PRIM",
+    (char *)"CSR_WIFI_ROUTER_PRIM",
     csrwifirouter_conv_lut
 };
 const CsrLogPrimitiveInformation* CsrWifiRouterTechInfoGet(void)

drivers/staging/csr/csr_wifi_router_ctrl_converter_init.c

@@ -123,7 +123,7 @@ void CsrWifiRouterCtrlConverterInit(void)
 #ifdef CSR_LOG_ENABLE
 static const CsrLogPrimitiveInformation csrwifirouterctrl_conv_info = {
     CSR_WIFI_ROUTER_CTRL_PRIM,
-    (CsrCharString *)"CSR_WIFI_ROUTER_CTRL_PRIM",
+    (char *)"CSR_WIFI_ROUTER_CTRL_PRIM",
     csrwifirouterctrl_conv_lut
 };
 const CsrLogPrimitiveInformation* CsrWifiRouterCtrlTechInfoGet(void)

drivers/staging/csr/csr_wifi_router_ctrl_lib.h

@@ -56,34 +56,34 @@ void CsrWifiRouterCtrlFreeDownstreamMessageContents(u16 eventClass, void *messag
 /*----------------------------------------------------------------------------*
  * Enum to string functions
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiRouterCtrlBlockAckRoleToString(CsrWifiRouterCtrlBlockAckRole value);
-const CsrCharString* CsrWifiRouterCtrlControlIndicationToString(CsrWifiRouterCtrlControlIndication value);
-const CsrCharString* CsrWifiRouterCtrlListActionToString(CsrWifiRouterCtrlListAction value);
-const CsrCharString* CsrWifiRouterCtrlLowPowerModeToString(CsrWifiRouterCtrlLowPowerMode value);
-const CsrCharString* CsrWifiRouterCtrlMediaStatusToString(CsrWifiRouterCtrlMediaStatus value);
-const CsrCharString* CsrWifiRouterCtrlModeToString(CsrWifiRouterCtrlMode value);
-const CsrCharString* CsrWifiRouterCtrlPeerStatusToString(CsrWifiRouterCtrlPeerStatus value);
-const CsrCharString* CsrWifiRouterCtrlPortActionToString(CsrWifiRouterCtrlPortAction value);
-const CsrCharString* CsrWifiRouterCtrlPowersaveTypeToString(CsrWifiRouterCtrlPowersaveType value);
-const CsrCharString* CsrWifiRouterCtrlProtocolDirectionToString(CsrWifiRouterCtrlProtocolDirection value);
-const CsrCharString* CsrWifiRouterCtrlQoSControlToString(CsrWifiRouterCtrlQoSControl value);
-const CsrCharString* CsrWifiRouterCtrlQueueConfigToString(CsrWifiRouterCtrlQueueConfig value);
-const CsrCharString* CsrWifiRouterCtrlTrafficConfigTypeToString(CsrWifiRouterCtrlTrafficConfigType value);
-const CsrCharString* CsrWifiRouterCtrlTrafficPacketTypeToString(CsrWifiRouterCtrlTrafficPacketType value);
-const CsrCharString* CsrWifiRouterCtrlTrafficTypeToString(CsrWifiRouterCtrlTrafficType value);
+const char* CsrWifiRouterCtrlBlockAckRoleToString(CsrWifiRouterCtrlBlockAckRole value);
+const char* CsrWifiRouterCtrlControlIndicationToString(CsrWifiRouterCtrlControlIndication value);
+const char* CsrWifiRouterCtrlListActionToString(CsrWifiRouterCtrlListAction value);
+const char* CsrWifiRouterCtrlLowPowerModeToString(CsrWifiRouterCtrlLowPowerMode value);
+const char* CsrWifiRouterCtrlMediaStatusToString(CsrWifiRouterCtrlMediaStatus value);
+const char* CsrWifiRouterCtrlModeToString(CsrWifiRouterCtrlMode value);
+const char* CsrWifiRouterCtrlPeerStatusToString(CsrWifiRouterCtrlPeerStatus value);
+const char* CsrWifiRouterCtrlPortActionToString(CsrWifiRouterCtrlPortAction value);
+const char* CsrWifiRouterCtrlPowersaveTypeToString(CsrWifiRouterCtrlPowersaveType value);
+const char* CsrWifiRouterCtrlProtocolDirectionToString(CsrWifiRouterCtrlProtocolDirection value);
+const char* CsrWifiRouterCtrlQoSControlToString(CsrWifiRouterCtrlQoSControl value);
+const char* CsrWifiRouterCtrlQueueConfigToString(CsrWifiRouterCtrlQueueConfig value);
+const char* CsrWifiRouterCtrlTrafficConfigTypeToString(CsrWifiRouterCtrlTrafficConfigType value);
+const char* CsrWifiRouterCtrlTrafficPacketTypeToString(CsrWifiRouterCtrlTrafficPacketType value);
+const char* CsrWifiRouterCtrlTrafficTypeToString(CsrWifiRouterCtrlTrafficType value);
 
 
 /*----------------------------------------------------------------------------*
  * CsrPrim Type toString function.
  * Converts a message type to the String name of the Message
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiRouterCtrlPrimTypeToString(CsrPrim msgType);
+const char* CsrWifiRouterCtrlPrimTypeToString(CsrPrim msgType);
 
 /*----------------------------------------------------------------------------*
  * Lookup arrays for PrimType name Strings
  *----------------------------------------------------------------------------*/
-extern const CsrCharString *CsrWifiRouterCtrlUpstreamPrimNames[CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_COUNT];
-extern const CsrCharString *CsrWifiRouterCtrlDownstreamPrimNames[CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT];
+extern const char *CsrWifiRouterCtrlUpstreamPrimNames[CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_COUNT];
+extern const char *CsrWifiRouterCtrlDownstreamPrimNames[CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT];
 
 /*******************************************************************************
 

drivers/staging/csr/csr_wifi_router_ctrl_prim.h

@@ -468,7 +468,7 @@ typedef u8 CsrWifiRouterCtrlTrafficStreamId;
 typedef struct
 {
     u32      firmwarePatch;
-    CsrCharString *smeBuild;
+    char *smeBuild;
     u32      smeHip;
 } CsrWifiRouterCtrlSmeVersions;
 
@@ -564,7 +564,7 @@ typedef struct
     u32      chipVersion;
     u32      firmwareBuild;
     u32      firmwareHip;
-    CsrCharString *routerBuild;
+    char *routerBuild;
     u32      routerHip;
 } CsrWifiRouterCtrlVersions;
 

drivers/staging/csr/csr_wifi_router_ctrl_serialize.c

@@ -732,7 +732,7 @@ CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg)
         }
     }
     bufferSize += 4;                                                                                    /* u32 primitive->smeVersions.firmwarePatch */
-    bufferSize += (primitive->smeVersions.smeBuild?CsrStrLen(primitive->smeVersions.smeBuild) : 0) + 1; /* CsrCharString* primitive->smeVersions.smeBuild (0 byte len + 1 for NULL Term) */
+    bufferSize += (primitive->smeVersions.smeBuild?CsrStrLen(primitive->smeVersions.smeBuild) : 0) + 1; /* char* primitive->smeVersions.smeBuild (0 byte len + 1 for NULL Term) */
     bufferSize += 4;                                                                                    /* u32 primitive->smeVersions.smeHip */
     bufferSize += 1;                                                                                    /* CsrBool primitive->scheduledInterrupt */
     return bufferSize;
@@ -1793,7 +1793,7 @@ CsrSize CsrWifiRouterCtrlWifiOnIndSizeof(void *msg)
     bufferSize += 4;                                                                                    /* u32 primitive->versions.chipVersion */
     bufferSize += 4;                                                                                    /* u32 primitive->versions.firmwareBuild */
     bufferSize += 4;                                                                                    /* u32 primitive->versions.firmwareHip */
-    bufferSize += (primitive->versions.routerBuild?CsrStrLen(primitive->versions.routerBuild) : 0) + 1; /* CsrCharString* primitive->versions.routerBuild (0 byte len + 1 for NULL Term) */
+    bufferSize += (primitive->versions.routerBuild?CsrStrLen(primitive->versions.routerBuild) : 0) + 1; /* char* primitive->versions.routerBuild (0 byte len + 1 for NULL Term) */
     bufferSize += 4;                                                                                    /* u32 primitive->versions.routerHip */
     return bufferSize;
 }

drivers/staging/csr/csr_wifi_router_lib.h

@@ -56,23 +56,23 @@ void CsrWifiRouterFreeDownstreamMessageContents(u16 eventClass, void *message);
 /*----------------------------------------------------------------------------*
  * Enum to string functions
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiRouterAppTypeToString(CsrWifiRouterAppType value);
-const CsrCharString* CsrWifiRouterEncapsulationToString(CsrWifiRouterEncapsulation value);
-const CsrCharString* CsrWifiRouterOuiToString(CsrWifiRouterOui value);
-const CsrCharString* CsrWifiRouterPriorityToString(CsrWifiRouterPriority value);
+const char* CsrWifiRouterAppTypeToString(CsrWifiRouterAppType value);
+const char* CsrWifiRouterEncapsulationToString(CsrWifiRouterEncapsulation value);
+const char* CsrWifiRouterOuiToString(CsrWifiRouterOui value);
+const char* CsrWifiRouterPriorityToString(CsrWifiRouterPriority value);
 
 
 /*----------------------------------------------------------------------------*
  * CsrPrim Type toString function.
  * Converts a message type to the String name of the Message
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiRouterPrimTypeToString(CsrPrim msgType);
+const char* CsrWifiRouterPrimTypeToString(CsrPrim msgType);
 
 /*----------------------------------------------------------------------------*
  * Lookup arrays for PrimType name Strings
  *----------------------------------------------------------------------------*/
-extern const CsrCharString *CsrWifiRouterUpstreamPrimNames[CSR_WIFI_ROUTER_PRIM_UPSTREAM_COUNT];
-extern const CsrCharString *CsrWifiRouterDownstreamPrimNames[CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT];
+extern const char *CsrWifiRouterUpstreamPrimNames[CSR_WIFI_ROUTER_PRIM_UPSTREAM_COUNT];
+extern const char *CsrWifiRouterDownstreamPrimNames[CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT];
 
 /*******************************************************************************
 

drivers/staging/csr/csr_wifi_router_transport.c

@@ -198,7 +198,7 @@ static void CsrWifiRouterTransportSerialiseAndSend(u16 primType, void* msg)
 }
 
 #if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
-void CsrSchedMessagePutStringLog(CsrSchedQid q, u16 mi, void *mv, u32 line, CsrCharString *file)
+void CsrSchedMessagePutStringLog(CsrSchedQid q, u16 mi, void *mv, u32 line, char *file)
 #else
 void CsrSchedMessagePut(CsrSchedQid q, u16 mi, void *mv)
 #endif

drivers/staging/csr/csr_wifi_sme_ap_lib.h

@@ -60,25 +60,25 @@ void CsrWifiSmeApFreeDownstreamMessageContents(u16 eventClass, void *message);
 /*----------------------------------------------------------------------------*
  * Enum to string functions
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiSmeApAccessTypeToString(CsrWifiSmeApAccessType value);
-const CsrCharString* CsrWifiSmeApAuthSupportToString(CsrWifiSmeApAuthSupport value);
-const CsrCharString* CsrWifiSmeApAuthTypeToString(CsrWifiSmeApAuthType value);
-const CsrCharString* CsrWifiSmeApDirectionToString(CsrWifiSmeApDirection value);
-const CsrCharString* CsrWifiSmeApPhySupportToString(CsrWifiSmeApPhySupport value);
-const CsrCharString* CsrWifiSmeApTypeToString(CsrWifiSmeApType value);
+const char* CsrWifiSmeApAccessTypeToString(CsrWifiSmeApAccessType value);
+const char* CsrWifiSmeApAuthSupportToString(CsrWifiSmeApAuthSupport value);
+const char* CsrWifiSmeApAuthTypeToString(CsrWifiSmeApAuthType value);
+const char* CsrWifiSmeApDirectionToString(CsrWifiSmeApDirection value);
+const char* CsrWifiSmeApPhySupportToString(CsrWifiSmeApPhySupport value);
+const char* CsrWifiSmeApTypeToString(CsrWifiSmeApType value);
 
 
 /*----------------------------------------------------------------------------*
  * CsrPrim Type toString function.
  * Converts a message type to the String name of the Message
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiSmeApPrimTypeToString(CsrPrim msgType);
+const char* CsrWifiSmeApPrimTypeToString(CsrPrim msgType);
 
 /*----------------------------------------------------------------------------*
  * Lookup arrays for PrimType name Strings
  *----------------------------------------------------------------------------*/
-extern const CsrCharString *CsrWifiSmeApUpstreamPrimNames[CSR_WIFI_SME_AP_PRIM_UPSTREAM_COUNT];
-extern const CsrCharString *CsrWifiSmeApDownstreamPrimNames[CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_COUNT];
+extern const char *CsrWifiSmeApUpstreamPrimNames[CSR_WIFI_SME_AP_PRIM_UPSTREAM_COUNT];
+extern const char *CsrWifiSmeApDownstreamPrimNames[CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_COUNT];
 
 /*******************************************************************************
 

drivers/staging/csr/csr_wifi_sme_converter_init.c

@@ -189,7 +189,7 @@ void CsrWifiSmeConverterInit(void)
 #ifdef CSR_LOG_ENABLE
 static const CsrLogPrimitiveInformation csrwifisme_conv_info = {
     CSR_WIFI_SME_PRIM,
-    (CsrCharString *)"CSR_WIFI_SME_PRIM",
+    (char *)"CSR_WIFI_SME_PRIM",
     csrwifisme_conv_lut
 };
 const CsrLogPrimitiveInformation* CsrWifiSmeTechInfoGet(void)

drivers/staging/csr/csr_wifi_sme_lib.h

@@ -66,63 +66,63 @@ void CsrWifiSmeFreeDownstreamMessageContents(u16 eventClass, void *message);
 /*----------------------------------------------------------------------------*
  * Enum to string functions
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiSme80211NetworkTypeToString(CsrWifiSme80211NetworkType value);
-const CsrCharString* CsrWifiSme80211PrivacyModeToString(CsrWifiSme80211PrivacyMode value);
-const CsrCharString* CsrWifiSme80211dTrustLevelToString(CsrWifiSme80211dTrustLevel value);
-const CsrCharString* CsrWifiSmeAmpStatusToString(CsrWifiSmeAmpStatus value);
-const CsrCharString* CsrWifiSmeAuthModeToString(CsrWifiSmeAuthMode value);
-const CsrCharString* CsrWifiSmeBasicUsabilityToString(CsrWifiSmeBasicUsability value);
-const CsrCharString* CsrWifiSmeBssTypeToString(CsrWifiSmeBssType value);
-const CsrCharString* CsrWifiSmeCoexSchemeToString(CsrWifiSmeCoexScheme value);
-const CsrCharString* CsrWifiSmeControlIndicationToString(CsrWifiSmeControlIndication value);
-const CsrCharString* CsrWifiSmeCtsProtectionTypeToString(CsrWifiSmeCtsProtectionType value);
-const CsrCharString* CsrWifiSmeD3AutoScanModeToString(CsrWifiSmeD3AutoScanMode value);
-const CsrCharString* CsrWifiSmeEncryptionToString(CsrWifiSmeEncryption value);
-const CsrCharString* CsrWifiSmeFirmwareDriverInterfaceToString(CsrWifiSmeFirmwareDriverInterface value);
-const CsrCharString* CsrWifiSmeHostPowerModeToString(CsrWifiSmeHostPowerMode value);
-const CsrCharString* CsrWifiSmeIEEE80211ReasonToString(CsrWifiSmeIEEE80211Reason value);
-const CsrCharString* CsrWifiSmeIEEE80211ResultToString(CsrWifiSmeIEEE80211Result value);
-const CsrCharString* CsrWifiSmeIndicationsToString(CsrWifiSmeIndications value);
-const CsrCharString* CsrWifiSmeKeyTypeToString(CsrWifiSmeKeyType value);
-const CsrCharString* CsrWifiSmeListActionToString(CsrWifiSmeListAction value);
-const CsrCharString* CsrWifiSmeMediaStatusToString(CsrWifiSmeMediaStatus value);
-const CsrCharString* CsrWifiSmeP2pCapabilityToString(CsrWifiSmeP2pCapability value);
-const CsrCharString* CsrWifiSmeP2pGroupCapabilityToString(CsrWifiSmeP2pGroupCapability value);
-const CsrCharString* CsrWifiSmeP2pNoaConfigMethodToString(CsrWifiSmeP2pNoaConfigMethod value);
-const CsrCharString* CsrWifiSmeP2pRoleToString(CsrWifiSmeP2pRole value);
-const CsrCharString* CsrWifiSmeP2pStatusToString(CsrWifiSmeP2pStatus value);
-const CsrCharString* CsrWifiSmePacketFilterModeToString(CsrWifiSmePacketFilterMode value);
-const CsrCharString* CsrWifiSmePowerSaveLevelToString(CsrWifiSmePowerSaveLevel value);
-const CsrCharString* CsrWifiSmePreambleTypeToString(CsrWifiSmePreambleType value);
-const CsrCharString* CsrWifiSmeRadioIFToString(CsrWifiSmeRadioIF value);
-const CsrCharString* CsrWifiSmeRegulatoryDomainToString(CsrWifiSmeRegulatoryDomain value);
-const CsrCharString* CsrWifiSmeRoamReasonToString(CsrWifiSmeRoamReason value);
-const CsrCharString* CsrWifiSmeScanTypeToString(CsrWifiSmeScanType value);
-const CsrCharString* CsrWifiSmeTrafficTypeToString(CsrWifiSmeTrafficType value);
-const CsrCharString* CsrWifiSmeTspecCtrlToString(CsrWifiSmeTspecCtrl value);
-const CsrCharString* CsrWifiSmeTspecResultCodeToString(CsrWifiSmeTspecResultCode value);
-const CsrCharString* CsrWifiSmeWepAuthModeToString(CsrWifiSmeWepAuthMode value);
-const CsrCharString* CsrWifiSmeWepCredentialTypeToString(CsrWifiSmeWepCredentialType value);
-const CsrCharString* CsrWifiSmeWmmModeToString(CsrWifiSmeWmmMode value);
-const CsrCharString* CsrWifiSmeWmmQosInfoToString(CsrWifiSmeWmmQosInfo value);
-const CsrCharString* CsrWifiSmeWpsConfigTypeToString(CsrWifiSmeWpsConfigType value);
-const CsrCharString* CsrWifiSmeWpsDeviceCategoryToString(CsrWifiSmeWpsDeviceCategory value);
-const CsrCharString* CsrWifiSmeWpsDeviceSubCategoryToString(CsrWifiSmeWpsDeviceSubCategory value);
-const CsrCharString* CsrWifiSmeWpsDpidToString(CsrWifiSmeWpsDpid value);
-const CsrCharString* CsrWifiSmeWpsRegistrationToString(CsrWifiSmeWpsRegistration value);
+const char* CsrWifiSme80211NetworkTypeToString(CsrWifiSme80211NetworkType value);
+const char* CsrWifiSme80211PrivacyModeToString(CsrWifiSme80211PrivacyMode value);
+const char* CsrWifiSme80211dTrustLevelToString(CsrWifiSme80211dTrustLevel value);
+const char* CsrWifiSmeAmpStatusToString(CsrWifiSmeAmpStatus value);
+const char* CsrWifiSmeAuthModeToString(CsrWifiSmeAuthMode value);
+const char* CsrWifiSmeBasicUsabilityToString(CsrWifiSmeBasicUsability value);
+const char* CsrWifiSmeBssTypeToString(CsrWifiSmeBssType value);
+const char* CsrWifiSmeCoexSchemeToString(CsrWifiSmeCoexScheme value);
+const char* CsrWifiSmeControlIndicationToString(CsrWifiSmeControlIndication value);
+const char* CsrWifiSmeCtsProtectionTypeToString(CsrWifiSmeCtsProtectionType value);
+const char* CsrWifiSmeD3AutoScanModeToString(CsrWifiSmeD3AutoScanMode value);
+const char* CsrWifiSmeEncryptionToString(CsrWifiSmeEncryption value);
+const char* CsrWifiSmeFirmwareDriverInterfaceToString(CsrWifiSmeFirmwareDriverInterface value);
+const char* CsrWifiSmeHostPowerModeToString(CsrWifiSmeHostPowerMode value);
+const char* CsrWifiSmeIEEE80211ReasonToString(CsrWifiSmeIEEE80211Reason value);
+const char* CsrWifiSmeIEEE80211ResultToString(CsrWifiSmeIEEE80211Result value);
+const char* CsrWifiSmeIndicationsToString(CsrWifiSmeIndications value);
+const char* CsrWifiSmeKeyTypeToString(CsrWifiSmeKeyType value);
+const char* CsrWifiSmeListActionToString(CsrWifiSmeListAction value);
+const char* CsrWifiSmeMediaStatusToString(CsrWifiSmeMediaStatus value);
+const char* CsrWifiSmeP2pCapabilityToString(CsrWifiSmeP2pCapability value);
+const char* CsrWifiSmeP2pGroupCapabilityToString(CsrWifiSmeP2pGroupCapability value);
+const char* CsrWifiSmeP2pNoaConfigMethodToString(CsrWifiSmeP2pNoaConfigMethod value);
+const char* CsrWifiSmeP2pRoleToString(CsrWifiSmeP2pRole value);
+const char* CsrWifiSmeP2pStatusToString(CsrWifiSmeP2pStatus value);
+const char* CsrWifiSmePacketFilterModeToString(CsrWifiSmePacketFilterMode value);
+const char* CsrWifiSmePowerSaveLevelToString(CsrWifiSmePowerSaveLevel value);
+const char* CsrWifiSmePreambleTypeToString(CsrWifiSmePreambleType value);
+const char* CsrWifiSmeRadioIFToString(CsrWifiSmeRadioIF value);
+const char* CsrWifiSmeRegulatoryDomainToString(CsrWifiSmeRegulatoryDomain value);
+const char* CsrWifiSmeRoamReasonToString(CsrWifiSmeRoamReason value);
+const char* CsrWifiSmeScanTypeToString(CsrWifiSmeScanType value);
+const char* CsrWifiSmeTrafficTypeToString(CsrWifiSmeTrafficType value);
+const char* CsrWifiSmeTspecCtrlToString(CsrWifiSmeTspecCtrl value);
+const char* CsrWifiSmeTspecResultCodeToString(CsrWifiSmeTspecResultCode value);
+const char* CsrWifiSmeWepAuthModeToString(CsrWifiSmeWepAuthMode value);
+const char* CsrWifiSmeWepCredentialTypeToString(CsrWifiSmeWepCredentialType value);
+const char* CsrWifiSmeWmmModeToString(CsrWifiSmeWmmMode value);
+const char* CsrWifiSmeWmmQosInfoToString(CsrWifiSmeWmmQosInfo value);
+const char* CsrWifiSmeWpsConfigTypeToString(CsrWifiSmeWpsConfigType value);
+const char* CsrWifiSmeWpsDeviceCategoryToString(CsrWifiSmeWpsDeviceCategory value);
+const char* CsrWifiSmeWpsDeviceSubCategoryToString(CsrWifiSmeWpsDeviceSubCategory value);
+const char* CsrWifiSmeWpsDpidToString(CsrWifiSmeWpsDpid value);
+const char* CsrWifiSmeWpsRegistrationToString(CsrWifiSmeWpsRegistration value);
 
 
 /*----------------------------------------------------------------------------*
  * CsrPrim Type toString function.
  * Converts a message type to the String name of the Message
  *----------------------------------------------------------------------------*/
-const CsrCharString* CsrWifiSmePrimTypeToString(CsrPrim msgType);
+const char* CsrWifiSmePrimTypeToString(CsrPrim msgType);
 
 /*----------------------------------------------------------------------------*
  * Lookup arrays for PrimType name Strings
  *----------------------------------------------------------------------------*/
-extern const CsrCharString *CsrWifiSmeUpstreamPrimNames[CSR_WIFI_SME_PRIM_UPSTREAM_COUNT];
-extern const CsrCharString *CsrWifiSmeDownstreamPrimNames[CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT];
+extern const char *CsrWifiSmeUpstreamPrimNames[CSR_WIFI_SME_PRIM_UPSTREAM_COUNT];
+extern const char *CsrWifiSmeDownstreamPrimNames[CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT];
 
 /*******************************************************************************
 

drivers/staging/csr/csr_wifi_sme_prim.h

@@ -2455,9 +2455,9 @@ typedef struct
     u32      firmwareBuild;
     u32      firmwarePatch;
     u32      firmwareHip;
-    CsrCharString *routerBuild;
+    char *routerBuild;
     u32      routerHip;
-    CsrCharString *smeBuild;
+    char *smeBuild;
     u32      smeHip;
 } CsrWifiSmeVersions;
 
@@ -6419,7 +6419,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrCharString  *errorMessage;
+    char  *errorMessage;
 } CsrWifiSmeErrorInd;
 
 /*******************************************************************************
@@ -6439,7 +6439,7 @@ typedef struct
 typedef struct
 {
     CsrWifiFsmEvent common;
-    CsrCharString  *infoMessage;
+    char  *infoMessage;
 } CsrWifiSmeInfoInd;
 
 /*******************************************************************************

drivers/staging/csr/csr_wifi_sme_serialize.c

@@ -5421,9 +5421,9 @@ CsrSize CsrWifiSmeVersionsGetCfmSizeof(void *msg)
     bufferSize += 4;                                                                                    /* u32 primitive->versions.firmwareBuild */
     bufferSize += 4;                                                                                    /* u32 primitive->versions.firmwarePatch */
     bufferSize += 4;                                                                                    /* u32 primitive->versions.firmwareHip */
-    bufferSize += (primitive->versions.routerBuild?CsrStrLen(primitive->versions.routerBuild) : 0) + 1; /* CsrCharString* primitive->versions.routerBuild (0 byte len + 1 for NULL Term) */
+    bufferSize += (primitive->versions.routerBuild?CsrStrLen(primitive->versions.routerBuild) : 0) + 1; /* char* primitive->versions.routerBuild (0 byte len + 1 for NULL Term) */
     bufferSize += 4;                                                                                    /* u32 primitive->versions.routerHip */
-    bufferSize += (primitive->versions.smeBuild?CsrStrLen(primitive->versions.smeBuild) : 0) + 1;       /* CsrCharString* primitive->versions.smeBuild (0 byte len + 1 for NULL Term) */
+    bufferSize += (primitive->versions.smeBuild?CsrStrLen(primitive->versions.smeBuild) : 0) + 1;       /* char* primitive->versions.smeBuild (0 byte len + 1 for NULL Term) */
     bufferSize += 4;                                                                                    /* u32 primitive->versions.smeHip */
     return bufferSize;
 }
@@ -5676,7 +5676,7 @@ CsrSize CsrWifiSmeErrorIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 3) */
-    bufferSize += (primitive->errorMessage?CsrStrLen(primitive->errorMessage) : 0) + 1; /* CsrCharString* primitive->errorMessage (0 byte len + 1 for NULL Term) */
+    bufferSize += (primitive->errorMessage?CsrStrLen(primitive->errorMessage) : 0) + 1; /* char* primitive->errorMessage (0 byte len + 1 for NULL Term) */
     return bufferSize;
 }
 
@@ -5718,7 +5718,7 @@ CsrSize CsrWifiSmeInfoIndSizeof(void *msg)
     CsrSize bufferSize = 2;
 
     /* Calculate the Size of the Serialised Data. Could be more efficient (Try 3) */
-    bufferSize += (primitive->infoMessage?CsrStrLen(primitive->infoMessage) : 0) + 1; /* CsrCharString* primitive->infoMessage (0 byte len + 1 for NULL Term) */
+    bufferSize += (primitive->infoMessage?CsrStrLen(primitive->infoMessage) : 0) + 1; /* char* primitive->infoMessage (0 byte len + 1 for NULL Term) */
     return bufferSize;
 }
 

drivers/staging/csr/sme_sys.c

@@ -836,7 +836,7 @@ void CsrWifiRouterCtrlWifiOnReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
     versions.chipVersion = priv->card_info.chip_version;
     versions.firmwareBuild = priv->card_info.fw_build;
     versions.firmwareHip = priv->card_info.fw_hip_version;
-    versions.routerBuild = (CsrCharString*)CSR_WIFI_VERSION;
+    versions.routerBuild = (char*)CSR_WIFI_VERSION;
     versions.routerHip = (UNIFI_HIP_MAJOR_VERSION << 8) | UNIFI_HIP_MINOR_VERSION;
 
     CsrWifiRouterCtrlWifiOnIndSend(msg->source, 0, CSR_RESULT_SUCCESS, versions);
@@ -1852,7 +1852,7 @@ void CsrWifiRouterCtrlModeSetReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
             versions.chipVersion = priv->card_info.chip_version;
             versions.firmwareBuild = priv->card_info.fw_build;
             versions.firmwareHip = priv->card_info.fw_hip_version;
-            versions.routerBuild = (CsrCharString*)CSR_WIFI_VERSION;
+            versions.routerBuild = (char*)CSR_WIFI_VERSION;
             versions.routerHip = (UNIFI_HIP_MAJOR_VERSION << 8) | UNIFI_HIP_MINOR_VERSION;
 
             /* Now that new firmware is running, send a WifiOnInd to the NME. This will