mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-08-25 10:19:47 +00:00
Code Issues Releases Wiki Activity

staging: csr: remove CsrCharString typedef

Browse source 
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>
This commit is contained in:
Greg Kroah-Hartman 2012-07-20 12:22:32 -07:00
parent 7f5393ea2d
commit c781b96b80
45 changed files with 298 additions and 301 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
drivers/staging/csr/csr_formatted_io.c
View file

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

2
drivers/staging/csr/csr_formatted_io.h
View file

@ -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
}

8
drivers/staging/csr/csr_framework_ext.h
View file

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

8
drivers/staging/csr/csr_lib.h
View file

@ -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
}

40
drivers/staging/csr/csr_log.h
View file

@ -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
}

4
drivers/staging/csr/csr_log_configure.h
View file

@ -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

24
drivers/staging/csr/csr_log_text.h
View file

@ -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

6
drivers/staging/csr/csr_msgconv.h
View file

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

10
drivers/staging/csr/csr_pmem.h
View file

@ -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

14
drivers/staging/csr/csr_sched.h
View file

@ -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

18
drivers/staging/csr/csr_serialize_primitive_types.c
View file

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

3
drivers/staging/csr/csr_types.h
View file

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

16
drivers/staging/csr/csr_utf16.c
View file

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

54
drivers/staging/csr/csr_util.c
View file

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

42
drivers/staging/csr/csr_util.h
View file

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

8
drivers/staging/csr/csr_wifi_fsm_types.h
View file

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

6
drivers/staging/csr/csr_wifi_hip_card.h
View file

@ -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

2
drivers/staging/csr/csr_wifi_hip_card_sdio.c
View file

@ -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[] = {

4
drivers/staging/csr/csr_wifi_hip_card_sdio.h
View file

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

20
drivers/staging/csr/csr_wifi_hip_card_sdio_intr.c
View file

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

4
drivers/staging/csr/csr_wifi_hip_chiphelper.h
View file

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

4
drivers/staging/csr/csr_wifi_hip_chiphelper_private.h
View file

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

6
drivers/staging/csr/csr_wifi_hip_udi.c
View file

@ -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

6
drivers/staging/csr/csr_wifi_hip_unifi.h
View file

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

4
drivers/staging/csr/csr_wifi_hip_unifi_signal_names.c
View file

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

2
drivers/staging/csr/csr_wifi_hip_unifi_udi.h
View file

@ -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 { \

26
drivers/staging/csr/csr_wifi_hip_xbv.c
View file

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

2
drivers/staging/csr/csr_wifi_nme_ap_converter_init.c
View file

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

8
drivers/staging/csr/csr_wifi_nme_ap_lib.h
View file

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

2
drivers/staging/csr/csr_wifi_nme_ap_serialize.c
View file

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

32
drivers/staging/csr/csr_wifi_nme_lib.h
View file

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

14
drivers/staging/csr/csr_wifi_nme_prim.h
View file

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

2
drivers/staging/csr/csr_wifi_router_converter_init.c
View file

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

2
drivers/staging/csr/csr_wifi_router_ctrl_converter_init.c
View file

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

36
drivers/staging/csr/csr_wifi_router_ctrl_lib.h
View file

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

4
drivers/staging/csr/csr_wifi_router_ctrl_prim.h
View file

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

4
drivers/staging/csr/csr_wifi_router_ctrl_serialize.c
View file

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

14
drivers/staging/csr/csr_wifi_router_lib.h
View file

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

2
drivers/staging/csr/csr_wifi_router_transport.c
View file

@ -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

18
drivers/staging/csr/csr_wifi_sme_ap_lib.h
View file

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

2
drivers/staging/csr/csr_wifi_sme_converter_init.c
View file

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

94
drivers/staging/csr/csr_wifi_sme_lib.h
View file

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

8
drivers/staging/csr/csr_wifi_sme_prim.h
View file

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

8
drivers/staging/csr/csr_wifi_sme_serialize.c
View file

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

4
drivers/staging/csr/sme_sys.c
View file

@ -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