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>
#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;
#include "csr_types.h"
-s32 CsrSnprintf(CsrCharString *dest, CsrSize n, const CsrCharString *fmt, ...);
+s32 CsrSnprintf(char *dest, CsrSize n, const char *fmt, ...);
#ifdef __cplusplus
}
*----------------------------------------------------------------------------*/
CsrResult CsrThreadCreate(void (*threadFunction)(void *pointer), void *pointer,
u32 stackSize, u16 priority,
- const CsrCharString *threadName, CsrThreadHandle *threadHandle);
+ const char *threadName, CsrThreadHandle *threadHandle);
/*----------------------------------------------------------------------------*
* NAME
*----------------------------------------------------------------------------*/
#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);
*----------------------------------------------------------------------------*/
#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);
*----------------------------------------------------------------------------*/
#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);
{
CsrPrim type;
u16 value1;
- CsrCharString *value2;
+ char *value2;
} CsrEventCsrUint16CsrCharString;
/*----------------------------------------------------------------------------*
* 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
{
{
CsrPrim type;
u32 value1;
- CsrCharString *value2;
+ char *value2;
} CsrEventCsrUint32CsrCharString;
/*----------------------------------------------------------------------------*
* 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
}
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)
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;
#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)
/* 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 */
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);
#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,
const void *msg);
void CsrLogTimedEventIn(u32 line,
- const CsrCharString *file,
+ const char *file,
CsrSchedQid task_id,
CsrSchedTid tid,
CsrTime requested_delay,
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);
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
}
sub origin(s).
*******************************************************************************/
-void CsrLogLevelTextSet(const CsrCharString *originName,
- const CsrCharString *subOriginName,
+void CsrLogLevelTextSet(const char *originName,
+ const char *subOriginName,
CsrLogLevelText warningLevelMask);
#ifdef __cplusplus
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
/* 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
/* 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
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
/* 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
/* 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
/* 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);
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);
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);
*****************************************************************************/
#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);
#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
*----------------------------------------------------------------------------*/
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
*----------------------------------------------------------------------------*/
CsrSchedBgint CsrSchedBgintReg(CsrSchedBgintHandler cb,
void *context,
- const CsrCharString *id);
+ const char *id);
/*----------------------------------------------------------------------------*
* NAME
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,
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,
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,
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,
* 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
}
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)
}
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
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)
CsrSizeSer(buffer, offset, (CsrSize) ptr);
}
-u32 CsrCharStringSerLen(const CsrCharString *str)
+u32 CsrCharStringSerLen(const char *str)
{
if (str)
{
{
if (str)
{
- return (u32) (CsrStrLen((CsrCharString *) str) + sizeof(*str));
+ return (u32) (CsrStrLen((char *) str) + sizeof(*str));
}
else
{
/* Boolean */
typedef u8 CsrBool;
-/* String types */
-typedef char CsrCharString;
-
/*
* 64-bit integers
*
{
return NULL;
}
- sourceLength = CsrStrLen((CsrCharString *) utf8String);
+ sourceLength = CsrStrLen((char *) utf8String);
for (i = 0; i < sourceLength; i++)
{
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)
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)
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);
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)
/*------------------------------------------------------------------*/
/* Base conversion */
/*------------------------------------------------------------------*/
-CsrBool CsrHexStrToUint8(const CsrCharString *string, u8 *returnValue)
+CsrBool CsrHexStrToUint8(const char *string, u8 *returnValue)
{
u16 currentIndex = 0;
*returnValue = 0;
return FALSE;
}
-CsrBool CsrHexStrToUint16(const CsrCharString *string, u16 *returnValue)
+CsrBool CsrHexStrToUint16(const char *string, u16 *returnValue)
{
u16 currentIndex = 0;
*returnValue = 0;
return FALSE;
}
-CsrBool CsrHexStrToUint32(const CsrCharString *string, u32 *returnValue)
+CsrBool CsrHexStrToUint32(const char *string, u32 *returnValue)
{
u16 currentIndex = 0;
*returnValue = 0;
/* 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++)
CsrStrCpy(str, res);
}
-void CsrUInt16ToHex(u16 number, CsrCharString *str)
+void CsrUInt16ToHex(u16 number, char *str)
{
u16 index;
u16 currentValue;
str[4] = '\0';
}
-void CsrUInt32ToHex(u32 number, CsrCharString *str)
+void CsrUInt32ToHex(u32 number, char *str)
{
u16 index;
u32 currentValue;
#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);
}
/* Convert string with base 10 to integer */
-u32 CsrStrToInt(const CsrCharString *str)
+u32 CsrStrToInt(const char *str)
{
s16 i;
u32 res;
return res;
}
-CsrCharString *CsrStrDup(const CsrCharString *string)
+char *CsrStrDup(const char *string)
{
- CsrCharString *copy;
+ char *copy;
u32 len;
copy = NULL;
return copy;
}
-int CsrStrNICmp(const CsrCharString *string1,
- const CsrCharString *string2,
+int CsrStrNICmp(const char *string1,
+ const char *string2,
CsrSize count)
{
u32 index;
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)
{
/*------------------------------------------------------------------*/
/* 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 */
#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 */
u32 eventid;
CsrWifiFsmTransitionFnPtr transition;
#ifdef CSR_LOG_ENABLE
- const CsrCharString *transitionName;
+ const char *transitionName;
#endif
} CsrWifiFsmEventEntry;
const CsrWifiFsmEventEntry *eventEntryArray; /* array of transition function pointers for state */
#ifdef CSR_LOG_ENABLE
u16 stateNumber;
- const CsrCharString *stateName;
+ const char *stateName;
#endif
} CsrWifiFsmTableEntry;
*/
typedef struct
{
- const CsrCharString *processName;
+ const char *processName;
const u32 processId;
const CsrWifiFsmTransitionFunctionTable transitionTable;
const CsrWifiFsmTableEntry unhandledTransitions;
CsrWifiFsmTransitionFnPtr transitionFn;
u16 transitionCount; /* number consecutive of times this transition was seen */
#ifdef CSR_LOG_ENABLE
- const CsrCharString *transitionName;
+ const char *transitionName;
#endif
} CsrWifiFsmTransitionRecord;
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
{
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[] = {
u16 q_wr_ptr;
u16 q_rd_ptr;
- CsrCharString name[UNIFI_QUEUE_NAME_MAX_LENGTH];
+ char name[UNIFI_QUEUE_NAME_MAX_LENGTH];
} q_t;
/* 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;
*/
#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;
} /* 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);
}
-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);
*
* ---------------------------------------------------------------------------
*/
-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)
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)) \
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;
* 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;
#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
/* 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 */
struct sig_name
{
s16 id;
- const CsrCharString *name;
+ const char *name;
};
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)
{
* 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 { \
/* Struct to represent a TLV field */
typedef struct
{
- CsrCharString t_name[4];
+ char t_name[4];
u32 t_len;
} tag_t;
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);
}
else if (TAG_EQ(tag.t_name, "LIST"))
{
- CsrCharString name[4];
+ char name[4];
u32 list_end;
list_end = ct.ioffset + tag.t_len;
}
-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);
}
-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);
* 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;
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);
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 */
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;
#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)
/*----------------------------------------------------------------------------*
* 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];
/*******************************************************************************
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;
/*----------------------------------------------------------------------------*
* 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];
/*******************************************************************************
typedef struct
{
u16 encryptionMode;
- CsrCharString *passphrase;
+ char *passphrase;
} CsrWifiNmePassphrase;
/*******************************************************************************
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;
/*******************************************************************************
{
CsrWifiFsmEvent common;
CsrResult status;
- CsrCharString *imsi;
+ char *imsi;
CsrWifiNmeSimCardType cardType;
} CsrWifiNmeSimImsiGetRes;
#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)
#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)
/*----------------------------------------------------------------------------*
* 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];
/*******************************************************************************
typedef struct
{
u32 firmwarePatch;
- CsrCharString *smeBuild;
+ char *smeBuild;
u32 smeHip;
} CsrWifiRouterCtrlSmeVersions;
u32 chipVersion;
u32 firmwareBuild;
u32 firmwareHip;
- CsrCharString *routerBuild;
+ char *routerBuild;
u32 routerHip;
} CsrWifiRouterCtrlVersions;
}
}
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;
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;
}
/*----------------------------------------------------------------------------*
* 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];
/*******************************************************************************
}
#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
/*----------------------------------------------------------------------------*
* 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];
/*******************************************************************************
#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)
/*----------------------------------------------------------------------------*
* 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];
/*******************************************************************************
u32 firmwareBuild;
u32 firmwarePatch;
u32 firmwareHip;
- CsrCharString *routerBuild;
+ char *routerBuild;
u32 routerHip;
- CsrCharString *smeBuild;
+ char *smeBuild;
u32 smeHip;
} CsrWifiSmeVersions;
typedef struct
{
CsrWifiFsmEvent common;
- CsrCharString *errorMessage;
+ char *errorMessage;
} CsrWifiSmeErrorInd;
/*******************************************************************************
typedef struct
{
CsrWifiFsmEvent common;
- CsrCharString *infoMessage;
+ char *infoMessage;
} CsrWifiSmeInfoInd;
/*******************************************************************************
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;
}
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;
}
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;
}
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);
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
projects / deliverable / linux.git / commitdiff
