microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

staging: csr: remove CsrSize typedef 

Use size_t 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:27:19 -07:00
Родитель 5379b13d9e
Коммит d4fda8db97
28 изменённых файлов: 1479 добавлений и 1480 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
drivers/staging/csr/csr_formatted_io.c
Просмотреть файл

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

2
drivers/staging/csr/csr_formatted_io.h
Просмотреть файл

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

6
drivers/staging/csr/csr_framework_ext.c
Просмотреть файл

@ -161,7 +161,7 @@ EXPORT_SYMBOL_GPL(CsrThreadSleep);
* Allocated memory is zero initialised.
*
*----------------------------------------------------------------------------*/
void *CsrMemCalloc(CsrSize numberOfElements, CsrSize elementSize)
void *CsrMemCalloc(size_t numberOfElements, size_t elementSize)
{
void *buf;
size_t size;
@ -189,7 +189,7 @@ void *CsrMemCalloc(CsrSize numberOfElements, CsrSize elementSize)
* Allocated memory is not initialised.
*
*----------------------------------------------------------------------------*/
void *CsrMemAlloc(CsrSize size)
void *CsrMemAlloc(size_t size)
{
return kmalloc(size, GFP_KERNEL);
}
@ -224,7 +224,7 @@ EXPORT_SYMBOL_GPL(CsrMemFree);
* Allocated memory is not initialised.
*
*----------------------------------------------------------------------------*/
void *CsrMemAllocDma(CsrSize size)
void *CsrMemAllocDma(size_t size)
{
return kmalloc(size, GFP_KERNEL | GFP_DMA);
}

12
drivers/staging/csr/csr_framework_ext.h
Просмотреть файл

@ -256,11 +256,11 @@ void CsrThreadSleep(u16 sleepTimeInMs);
*
*----------------------------------------------------------------------------*/
#ifdef CSR_MEM_DEBUG
void *CsrMemAllocDebug(CsrSize size,
void *CsrMemAllocDebug(size_t size,
const char *file, u32 line);
#define CsrMemAlloc(sz) CsrMemAllocDebug((sz), __FILE__, __LINE__)
#else
void *CsrMemAlloc(CsrSize size);
void *CsrMemAlloc(size_t size);
#endif
/*----------------------------------------------------------------------------*
@ -277,11 +277,11 @@ void *CsrMemAlloc(CsrSize size);
*
*----------------------------------------------------------------------------*/
#ifdef CSR_MEM_DEBUG
void *CsrMemCallocDebug(CsrSize numberOfElements, CsrSize elementSize,
void *CsrMemCallocDebug(size_t numberOfElements, size_t elementSize,
const char *file, u32 line);
#define CsrMemCalloc(cnt, sz) CsrMemAllocDebug((cnt), (sz), __FILE__, __LINE__)
#else
void *CsrMemCalloc(CsrSize numberOfElements, CsrSize elementSize);
void *CsrMemCalloc(size_t numberOfElements, size_t elementSize);
#endif
/*----------------------------------------------------------------------------*
@ -310,11 +310,11 @@ void CsrMemFree(void *pointer);
*
*----------------------------------------------------------------------------*/
#ifdef CSR_MEM_DEBUG
void *CsrMemAllocDmaDebug(CsrSize size,
void *CsrMemAllocDmaDebug(size_t size,
const char *file, u32 line);
#define CsrMemAllocDma(sz) CsrMemAllocDmaDebug((sz), __FILE__, __LINE__)
#else
void *CsrMemAllocDma(CsrSize size);
void *CsrMemAllocDma(size_t size);
#endif

10
drivers/staging/csr/csr_log_text.h
Просмотреть файл

@ -34,7 +34,7 @@ void CsrLogTextRegister(CsrLogTextTaskId taskId, const char *taskName, u16 subOr
system as a whole. */
#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_CRITICAL_DISABLE)
void CsrLogTextCritical(CsrLogTextTaskId taskId, u16 subOrigin, const char *formatString, ...);
void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, size_t 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
@ -50,7 +50,7 @@ void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bu
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 char *formatString, ...);
void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, size_t 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
@ -67,7 +67,7 @@ void CsrLogTextBufferError(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize buffe
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 char *formatString, ...);
void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, size_t 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
@ -83,7 +83,7 @@ void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize buf
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 char *formatString, ...);
void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, u16 subOrigin, size_t 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
@ -98,7 +98,7 @@ 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 char *formatString, ...);
void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, u16 subOrigin, CsrSize bufferLength, const void *buffer, const char *formatString, ...);
void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, u16 subOrigin, size_t 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

16
drivers/staging/csr/csr_msgconv.c
Просмотреть файл

@ -72,7 +72,7 @@ static const CsrMsgConvMsgEntry *find_msg_converter(CsrMsgConvPrimEntry *ptr, u1
}
static void *deserialize_data(u16 primType,
CsrSize length,
size_t length,
u8 *data)
{
CsrMsgConvPrimEntry *ptr;
@ -84,7 +84,7 @@ static void *deserialize_data(u16 primType,
{
const CsrMsgConvMsgEntry *cv;
u16 msgId = 0;
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&msgId, data, &offset);
cv = find_msg_converter(ptr, msgId);
@ -105,10 +105,10 @@ static void *deserialize_data(u16 primType,
return ret;
}
static CsrSize sizeof_message(u16 primType, void *msg)
static size_t sizeof_message(u16 primType, void *msg)
{
CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
CsrSize ret;
size_t ret;
if (ptr)
{
@ -166,7 +166,7 @@ static u8 free_message(u16 primType, u8 *data)
static u8 *serialize_message(u16 primType,
void *msg,
CsrSize *length,
size_t *length,
u8 *buffer)
{
CsrMsgConvPrimEntry *ptr;
@ -198,16 +198,16 @@ static u8 *serialize_message(u16 primType,
return ret;
}
CsrSize CsrMsgConvSizeof(u16 primType, void *msg)
size_t CsrMsgConvSizeof(u16 primType, void *msg)
{
return sizeof_message(primType, msg);
}
u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, u16 primType, void *msg)
u8 *CsrMsgConvSerialize(u8 *buffer, size_t maxBufferOffset, size_t *offset, u16 primType, void *msg)
{
if (converter)
{
CsrSize serializedLength;
size_t serializedLength;
u8 *bufSerialized;
u8 *bufOffset = &buffer[*offset];
bufSerialized = converter->serialize_message(primType, msg, &serializedLength, bufOffset);

112
drivers/staging/csr/csr_msgconv.h
Просмотреть файл

@ -20,10 +20,10 @@
extern "C" {
#endif
typedef CsrSize (CsrMsgSizeofFunc)(void *msg);
typedef u8 *(CsrMsgSerializeFunc)(u8 *buffer, CsrSize *length, void *msg);
typedef size_t (CsrMsgSizeofFunc)(void *msg);
typedef u8 *(CsrMsgSerializeFunc)(u8 *buffer, size_t *length, void *msg);
typedef void (CsrMsgFreeFunc)(void *msg);
typedef void *(CsrMsgDeserializeFunc)(u8 *buffer, CsrSize length);
typedef void *(CsrMsgDeserializeFunc)(u8 *buffer, size_t length);
/* Converter entry for one message type */
typedef struct CsrMsgConvMsgEntry
@ -50,16 +50,16 @@ typedef struct CsrMsgConvPrimEntry
typedef struct
{
CsrMsgConvPrimEntry *profile_converters;
void *(*deserialize_data)(u16 primType, CsrSize length, u8 * data);
void *(*deserialize_data)(u16 primType, size_t length, u8 * data);
u8 (*free_message)(u16 primType, u8 *data);
CsrSize (*sizeof_message)(u16 primType, void *msg);
size_t (*sizeof_message)(u16 primType, void *msg);
u8 *(*serialize_message)(u16 primType, void *msg,
CsrSize * length,
size_t * length,
u8 * buffer);
} CsrMsgConvEntry;
CsrSize CsrMsgConvSizeof(u16 primType, void *msg);
u8 *CsrMsgConvSerialize(u8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, u16 primType, void *msg);
size_t CsrMsgConvSizeof(u16 primType, void *msg);
u8 *CsrMsgConvSerialize(u8 *buffer, size_t maxBufferOffset, size_t *offset, u16 primType, void *msg);
void CsrMsgConvCustomLookupRegister(u16 primType, CsrMsgCustomLookupFunc *lookupFunc);
void CsrMsgConvInsert(u16 primType, const CsrMsgConvMsgEntry *ce);
CsrMsgConvPrimEntry *CsrMsgConvFind(u16 primType);
@ -78,65 +78,65 @@ u32 CsrUtf8StringSerLen(const u8 *str);
u32 CsrUtf16StringSerLen(const u16 *str);
/* Prototypes for primitive type serializers */
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 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 CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value);
void CsrUint8Ser(u8 *buffer, size_t *offset, u8 value);
void CsrUint16Ser(u8 *buffer, size_t *offset, u16 value);
void CsrUint32Ser(u8 *buffer, size_t *offset, u32 value);
void CsrMemCpySer(u8 *buffer, size_t *offset, const void *value, size_t length);
void CsrCharStringSer(u8 *buffer, size_t *offset, const char *value);
void CsrUtf8StringSer(u8 *buffer, size_t *offset, const u8 *value);
void CsrUtf16StringSer(u8 *buffer, size_t *offset, const u16 *value);
void CsrVoidPtrSer(u8 *buffer, size_t *offset, void *ptr);
void CsrSizeSer(u8 *buffer, size_t *offset, size_t value);
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(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);
void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset);
void CsrUint8Des(u8 *value, u8 *buffer, size_t *offset);
void CsrUint16Des(u16 *value, u8 *buffer, size_t *offset);
void CsrUint32Des(u32 *value, u8 *buffer, size_t *offset);
void CsrMemCpyDes(void *value, u8 *buffer, size_t *offset, size_t length);
void CsrCharStringDes(char **value, u8 *buffer, size_t *offset);
void CsrUtf8StringDes(u8 **value, u8 *buffer, size_t *offset);
void CsrUtf16StringDes(u16 **value, u8 *buffer, size_t *offset);
void CsrVoidPtrDes(void **value, u8 *buffer, size_t *offset);
void CsrSizeDes(size_t *value, u8 *buffer, size_t *offset);
CsrSize CsrEventSizeof(void *msg);
u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg);
void *CsrEventDes(u8 *buffer, CsrSize length);
size_t CsrEventSizeof(void *msg);
u8 *CsrEventSer(u8 *ptr, size_t *len, void *msg);
void *CsrEventDes(u8 *buffer, size_t length);
CsrSize CsrEventCsrUint8Sizeof(void *msg);
u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
void *CsrEventCsrUint8Des(u8 *buffer, CsrSize length);
size_t CsrEventCsrUint8Sizeof(void *msg);
u8 *CsrEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg);
void *CsrEventCsrUint8Des(u8 *buffer, size_t length);
CsrSize CsrEventCsrUint16Sizeof(void *msg);
u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
void *CsrEventCsrUint16Des(u8 *buffer, CsrSize length);
size_t CsrEventCsrUint16Sizeof(void *msg);
u8 *CsrEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg);
void *CsrEventCsrUint16Des(u8 *buffer, size_t length);
CsrSize CsrEventCsrUint32Sizeof(void *msg);
u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
void *CsrEventCsrUint32Des(u8 *buffer, CsrSize length);
size_t CsrEventCsrUint32Sizeof(void *msg);
u8 *CsrEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg);
void *CsrEventCsrUint32Des(u8 *buffer, size_t length);
CsrSize CsrEventCsrUint16CsrUint8Sizeof(void *msg);
u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length);
size_t CsrEventCsrUint16CsrUint8Sizeof(void *msg);
u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg);
void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, size_t length);
CsrSize CsrEventCsrUint16CsrUint16Sizeof(void *msg);
u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length);
size_t CsrEventCsrUint16CsrUint16Sizeof(void *msg);
u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, size_t *len, void *msg);
void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, size_t length);
CsrSize CsrEventCsrUint16CsrUint32Sizeof(void *msg);
u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length);
size_t CsrEventCsrUint16CsrUint32Sizeof(void *msg);
u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, size_t *len, void *msg);
void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, size_t length);
CsrSize CsrEventCsrUint16CsrCharStringSizeof(void *msg);
u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg);
void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length);
size_t CsrEventCsrUint16CsrCharStringSizeof(void *msg);
u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, size_t *len, void *msg);
void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, size_t length);
CsrSize CsrEventCsrUint32CsrUint16Sizeof(void *msg);
u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length);
size_t CsrEventCsrUint32CsrUint16Sizeof(void *msg);
u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, size_t *len, void *msg);
void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, size_t length);
CsrSize CsrEventCsrUint32CsrCharStringSizeof(void *msg);
u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg);
void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, CsrSize length);
size_t CsrEventCsrUint32CsrCharStringSizeof(void *msg);
u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, size_t *len, void *msg);
void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, size_t length);
#ifdef __cplusplus
}

2
drivers/staging/csr/csr_pmem.c
Просмотреть файл

@ -24,7 +24,7 @@
#include "csr_panic.h"
#include "csr_pmem.h"
void *CsrPmemAlloc(CsrSize size)
void *CsrPmemAlloc(size_t size)
{
void *ret;

8
drivers/staging/csr/csr_pmem.h
Просмотреть файл

@ -38,11 +38,11 @@ extern "C" {
*****************************************************************************/
#ifdef CSR_PMEM_DEBUG
void *CsrPmemAllocDebug(CsrSize size,
void *CsrPmemAllocDebug(size_t size,
const char *file, u32 line);
#define CsrPmemAlloc(sz) CsrPmemAllocDebug((sz), __FILE__, __LINE__)
#else
void *CsrPmemAlloc(CsrSize size);
void *CsrPmemAlloc(size_t size);
#endif
@ -108,7 +108,7 @@ 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 char* file, u32 line);
typedef void (CsrPmemDebugOnAlloc)(void *ptr, void *userptr, size_t size, CsrPmemDebugAllocType type, const char* file, u32 line);
typedef void (CsrPmemDebugOnFree)(void *ptr, void *userptr, CsrPmemDebugAllocType type, const char* file, u32 line);
/*----------------------------------------------------------------------------*
@ -127,7 +127,7 @@ 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 char* file, u32 line);
void *CsrPmemDebugAlloc(size_t 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 char* file, u32 line);

120
drivers/staging/csr/csr_serialize_primitive_types.c
Просмотреть файл

@ -16,14 +16,14 @@
#include "csr_pmem.h"
#include "csr_lib.h"
void CsrUint8Des(u8 *value, u8 *buffer, CsrSize *offset)
void CsrUint8Des(u8 *value, u8 *buffer, size_t *offset)
{
*value = buffer[*offset];
*offset += sizeof(*value);
}
EXPORT_SYMBOL_GPL(CsrUint8Des);
void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset)
void CsrUint16Des(u16 *value, u8 *buffer, size_t *offset)
{
*value = (buffer[*offset + 0] << 0) |
(buffer[*offset + 1] << 8);
@ -31,7 +31,7 @@ void CsrUint16Des(u16 *value, u8 *buffer, CsrSize *offset)
}
EXPORT_SYMBOL_GPL(CsrUint16Des);
void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset)
void CsrUint32Des(u32 *value, u8 *buffer, size_t *offset)
{
*value = (buffer[*offset + 0] << 0) |
(buffer[*offset + 1] << 8) |
@ -41,27 +41,27 @@ void CsrUint32Des(u32 *value, u8 *buffer, CsrSize *offset)
}
EXPORT_SYMBOL_GPL(CsrUint32Des);
void CsrMemCpyDes(void *value, u8 *buffer, CsrSize *offset, CsrSize length)
void CsrMemCpyDes(void *value, u8 *buffer, size_t *offset, size_t length)
{
CsrMemCpy(value, &buffer[*offset], length);
*offset += length;
}
EXPORT_SYMBOL_GPL(CsrMemCpyDes);
void CsrCharStringDes(char **value, u8 *buffer, CsrSize *offset)
void CsrCharStringDes(char **value, u8 *buffer, size_t *offset)
{
*value = CsrStrDup((char *) &buffer[*offset]);
*offset += CsrStrLen(*value) + 1;
}
EXPORT_SYMBOL_GPL(CsrCharStringDes);
void CsrUtf8StringDes(u8 **value, u8 *buffer, CsrSize *offset)
void CsrUtf8StringDes(u8 **value, u8 *buffer, size_t *offset)
{
*value = (u8 *) CsrStrDup((char *) &buffer[*offset]);
*offset += CsrStrLen((char *) *value) + 1;
}
void CsrUtf16StringDes(u16 **value, u8 *buffer, CsrSize *offset)
void CsrUtf16StringDes(u16 **value, u8 *buffer, size_t *offset)
{
u32 length, i;
@ -74,7 +74,7 @@ void CsrUtf16StringDes(u16 **value, u8 *buffer, CsrSize *offset)
}
}
void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset)
void CsrSizeDes(size_t *value, u8 *buffer, size_t *offset)
{
*value = (buffer[*offset + 0] << 0) |
(buffer[*offset + 1] << 8) |
@ -83,19 +83,19 @@ void CsrSizeDes(CsrSize *value, u8 *buffer, CsrSize *offset)
*offset += sizeof(*value);
}
void CsrVoidPtrDes(void **value, u8 *buffer, CsrSize *offset)
void CsrVoidPtrDes(void **value, u8 *buffer, size_t *offset)
{
CsrSizeDes((CsrSize *) value, buffer, offset);
CsrSizeDes((size_t *) value, buffer, offset);
}
void CsrUint8Ser(u8 *buffer, CsrSize *offset, u8 value)
void CsrUint8Ser(u8 *buffer, size_t *offset, u8 value)
{
buffer[*offset] = value;
*offset += sizeof(value);
}
EXPORT_SYMBOL_GPL(CsrUint8Ser);
void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value)
void CsrUint16Ser(u8 *buffer, size_t *offset, u16 value)
{
buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
@ -103,7 +103,7 @@ void CsrUint16Ser(u8 *buffer, CsrSize *offset, u16 value)
}
EXPORT_SYMBOL_GPL(CsrUint16Ser);
void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value)
void CsrUint32Ser(u8 *buffer, size_t *offset, u32 value)
{
buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
@ -113,14 +113,14 @@ void CsrUint32Ser(u8 *buffer, CsrSize *offset, u32 value)
}
EXPORT_SYMBOL_GPL(CsrUint32Ser);
void CsrMemCpySer(u8 *buffer, CsrSize *offset, const void *value, CsrSize length)
void CsrMemCpySer(u8 *buffer, size_t *offset, const void *value, size_t length)
{
CsrMemCpy(&buffer[*offset], value, length);
*offset += length;
}
EXPORT_SYMBOL_GPL(CsrMemCpySer);
void CsrCharStringSer(u8 *buffer, CsrSize *offset, const char *value)
void CsrCharStringSer(u8 *buffer, size_t *offset, const char *value)
{
if (value)
{
@ -134,12 +134,12 @@ void CsrCharStringSer(u8 *buffer, CsrSize *offset, const char *value)
}
EXPORT_SYMBOL_GPL(CsrCharStringSer);
void CsrUtf8StringSer(u8 *buffer, CsrSize *offset, const u8 *value)
void CsrUtf8StringSer(u8 *buffer, size_t *offset, const u8 *value)
{
CsrCharStringSer(buffer, offset, (char *) value);
}
void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const u16 *value)
void CsrUtf16StringSer(u8 *buffer, size_t *offset, const u16 *value)
{
if (value)
{
@ -159,7 +159,7 @@ void CsrUtf16StringSer(u8 *buffer, CsrSize *offset, const u16 *value)
}
}
void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value)
void CsrSizeSer(u8 *buffer, size_t *offset, size_t value)
{
buffer[*offset + 0] = (u8) ((value >> 0) & 0xFF);
buffer[*offset + 1] = (u8) ((value >> 8) & 0xFF);
@ -168,9 +168,9 @@ void CsrSizeSer(u8 *buffer, CsrSize *offset, CsrSize value)
*offset += sizeof(value);
}
void CsrVoidPtrSer(u8 *buffer, CsrSize *offset, void *ptr)
void CsrVoidPtrSer(u8 *buffer, size_t *offset, void *ptr)
{
CsrSizeSer(buffer, offset, (CsrSize) ptr);
CsrSizeSer(buffer, offset, (size_t) ptr);
}
u32 CsrCharStringSerLen(const char *str)
@ -210,12 +210,12 @@ u32 CsrUtf16StringSerLen(const u16 *str)
}
}
CsrSize CsrEventSizeof(void *msg)
size_t CsrEventSizeof(void *msg)
{
return 2;
}
u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg)
u8 *CsrEventSer(u8 *ptr, size_t *len, void *msg)
{
CsrEvent *primitive = (CsrEvent *) msg;
*len = 0;
@ -223,21 +223,21 @@ u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg)
return ptr;
}
void *CsrEventDes(u8 *buffer, CsrSize length)
void *CsrEventDes(u8 *buffer, size_t length)
{
CsrEvent *primitive = (CsrEvent *) CsrPmemAlloc(sizeof(CsrEvent));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
return primitive;
}
CsrSize CsrEventCsrUint8Sizeof(void *msg)
size_t CsrEventCsrUint8Sizeof(void *msg)
{
return 3;
}
u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
u8 *CsrEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg)
{
CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) msg;
*len = 0;
@ -246,23 +246,23 @@ u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
return ptr;
}
void *CsrEventCsrUint8Des(u8 *buffer, CsrSize length)
void *CsrEventCsrUint8Des(u8 *buffer, size_t length)
{
CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrEventCsrUint8));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
CsrUint8Des(&primitive->value, buffer, &offset);
return primitive;
}
CsrSize CsrEventCsrUint16Sizeof(void *msg)
size_t CsrEventCsrUint16Sizeof(void *msg)
{
return 4;
}
u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
u8 *CsrEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg)
{
CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) msg;
*len = 0;
@ -271,23 +271,23 @@ u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
return ptr;
}
void *CsrEventCsrUint16Des(u8 *buffer, CsrSize length)
void *CsrEventCsrUint16Des(u8 *buffer, size_t length)
{
CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
CsrUint16Des(&primitive->value, buffer, &offset);
return primitive;
}
CsrSize CsrEventCsrUint32Sizeof(void *msg)
size_t CsrEventCsrUint32Sizeof(void *msg)
{
return 6;
}
u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
u8 *CsrEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg)
{
CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) msg;
*len = 0;
@ -296,23 +296,23 @@ u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
return ptr;
}
void *CsrEventCsrUint32Des(u8 *buffer, CsrSize length)
void *CsrEventCsrUint32Des(u8 *buffer, size_t length)
{
CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrEventCsrUint32));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
CsrUint32Des(&primitive->value, buffer, &offset);
return primitive;
}
CsrSize CsrEventCsrUint16CsrUint8Sizeof(void *msg)
size_t CsrEventCsrUint16CsrUint8Sizeof(void *msg)
{
return 5;
}
u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg)
{
CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) msg;
*len = 0;
@ -322,11 +322,11 @@ u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
return ptr;
}
void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length)
void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, size_t length)
{
CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint8));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
CsrUint16Des(&primitive->value1, buffer, &offset);
CsrUint8Des(&primitive->value2, buffer, &offset);
@ -334,12 +334,12 @@ void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length)
return primitive;
}
CsrSize CsrEventCsrUint16CsrUint16Sizeof(void *msg)
size_t CsrEventCsrUint16CsrUint16Sizeof(void *msg)
{
return 6;
}
u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, size_t *len, void *msg)
{
CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) msg;
*len = 0;
@ -349,11 +349,11 @@ u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
return ptr;
}
void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length)
void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, size_t length)
{
CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint16));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
CsrUint16Des(&primitive->value1, buffer, &offset);
CsrUint16Des(&primitive->value2, buffer, &offset);
@ -361,12 +361,12 @@ void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length)
return primitive;
}
CsrSize CsrEventCsrUint16CsrUint32Sizeof(void *msg)
size_t CsrEventCsrUint16CsrUint32Sizeof(void *msg)
{
return 8;
}
u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, size_t *len, void *msg)
{
CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) msg;
*len = 0;
@ -376,11 +376,11 @@ u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
return ptr;
}
void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length)
void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, size_t length)
{
CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint32));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
CsrUint16Des(&primitive->value1, buffer, &offset);
CsrUint32Des(&primitive->value2, buffer, &offset);
@ -388,13 +388,13 @@ void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length)
return primitive;
}
CsrSize CsrEventCsrUint16CsrCharStringSizeof(void *msg)
size_t CsrEventCsrUint16CsrCharStringSizeof(void *msg)
{
CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
return 4 + CsrStrLen(primitive->value2) + 1;
}
u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, size_t *len, void *msg)
{
CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
*len = 0;
@ -404,11 +404,11 @@ u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
return ptr;
}
void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length)
void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, size_t length)
{
CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrCharString));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
CsrUint16Des(&primitive->value1, buffer, &offset);
CsrCharStringDes(&primitive->value2, buffer, &offset);
@ -416,12 +416,12 @@ void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length)
return primitive;
}
CsrSize CsrEventCsrUint32CsrUint16Sizeof(void *msg)
size_t CsrEventCsrUint32CsrUint16Sizeof(void *msg)
{
return 8;
}
u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, size_t *len, void *msg)
{
CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) msg;
*len = 0;
@ -431,11 +431,11 @@ u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
return ptr;
}
void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length)
void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, size_t length)
{
CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint32CsrUint16));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
CsrUint32Des(&primitive->value1, buffer, &offset);
CsrUint16Des(&primitive->value2, buffer, &offset);
@ -443,13 +443,13 @@ void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length)
return primitive;
}
CsrSize CsrEventCsrUint32CsrCharStringSizeof(void *msg)
size_t CsrEventCsrUint32CsrCharStringSizeof(void *msg)
{
CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
return 6 + CsrStrLen(primitive->value2) + 1;
}
u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, size_t *len, void *msg)
{
CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
*len = 0;
@ -459,11 +459,11 @@ u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg)
return ptr;
}
void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, CsrSize length)
void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, size_t length)
{
CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) CsrPmemAlloc(sizeof(CsrEventCsrUint32CsrCharString));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
CsrUint32Des(&primitive->value1, buffer, &offset);
CsrCharStringDes(&primitive->value2, buffer, &offset);

1
drivers/staging/csr/csr_types.h
Просмотреть файл

@ -27,7 +27,6 @@ extern "C" {
#define TRUE (1)
/* Basic types */
typedef size_t CsrSize; /* Return type of sizeof (ISO/IEC 9899:1990 7.1.6) */
typedef ptrdiff_t CsrPtrdiff; /* Type of the result of subtracting two pointers (ISO/IEC 9899:1990 7.1.6) */
typedef uintptr_t CsrUintptr; /* Unsigned integer large enough to hold any pointer (ISO/IEC 9899:1999 7.18.1.4) */
typedef ptrdiff_t CsrIntptr; /* intptr_t is not defined in kernel. Use the equivalent ptrdiff_t. */

12
drivers/staging/csr/csr_unicode.h
Просмотреть файл

@ -39,7 +39,7 @@ u16 *CsrUtf16String2XML(u16 *str);
u16 *CsrXML2Utf16String(u16 *str);
s32 CsrUtf8StrCmp(const u8 *string1, const u8 *string2);
s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, CsrSize count);
s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, size_t count);
u32 CsrUtf8StringLengthInBytes(const u8 *string);
/*******************************************************************************
@ -66,7 +66,7 @@ u32 CsrUtf8StringLengthInBytes(const u8 *string);
Returns target
*******************************************************************************/
u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count);
u8 *CsrUtf8StrTruncate(u8 *target, size_t count);
/*******************************************************************************
@ -116,7 +116,7 @@ u8 *CsrUtf8StrCpy(u8 *target, const u8 *source);
Returns target
*******************************************************************************/
u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count);
u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, size_t count);
/*******************************************************************************
@ -143,7 +143,7 @@ u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count);
Returns target
*******************************************************************************/
u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, CsrSize count);
u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, size_t count);
/*******************************************************************************
@ -174,8 +174,8 @@ u8 *CsrUtf8StringConcatenateTexts(const u8 *inputText1, const u8 *inputText2, co
*/
typedef u8 CsrUcs2String;
CsrSize CsrUcs2ByteStrLen(const CsrUcs2String *ucs2String);
CsrSize CsrConverterUcs2ByteStrLen(const CsrUcs2String *str);
size_t CsrUcs2ByteStrLen(const CsrUcs2String *ucs2String);
size_t CsrConverterUcs2ByteStrLen(const CsrUcs2String *str);
u8 *CsrUcs2ByteString2Utf8(const CsrUcs2String *ucs2String);
CsrUcs2String *CsrUtf82Ucs2ByteString(const u8 *utf8String);

16
drivers/staging/csr/csr_utf16.c
Просмотреть файл

@ -564,8 +564,8 @@ static u8 isLegalUtf8(const u8 *codeUnit, u32 length)
*********************************************************************************/
u16 *CsrUtf82Utf16String(const u8 *utf8String)
{
CsrSize i, length = 0;
CsrSize sourceLength;
size_t i, length = 0;
size_t sourceLength;
u16 *dest = NULL;
u16 *destStart = NULL;
s8 extraBytes2Read;
@ -1021,14 +1021,14 @@ s32 CsrUtf8StrCmp(const u8 *string1, const u8 *string2)
return CsrStrCmp((const char *) string1, (const char *) string2);
}
s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, CsrSize count)
s32 CsrUtf8StrNCmp(const u8 *string1, const u8 *string2, size_t count)
{
return CsrStrNCmp((const char *) string1, (const char *) string2, count);
}
u32 CsrUtf8StringLengthInBytes(const u8 *string)
{
CsrSize length = 0;
size_t length = 0;
if (string)
{
length = CsrStrLen((const char *) string);
@ -1041,9 +1041,9 @@ u8 *CsrUtf8StrCpy(u8 *target, const u8 *source)
return (u8 *) CsrStrCpy((char *) target, (const char *) source);
}
u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count)
u8 *CsrUtf8StrTruncate(u8 *target, size_t count)
{
CsrSize lastByte = count - 1;
size_t lastByte = count - 1;
target[count] = '\0';
@ -1070,12 +1070,12 @@ u8 *CsrUtf8StrTruncate(u8 *target, CsrSize count)
return target;
}
u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, CsrSize count)
u8 *CsrUtf8StrNCpy(u8 *target, const u8 *source, size_t count)
{
return (u8 *) CsrStrNCpy((char *) target, (const char *) source, count);
}
u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, CsrSize count)
u8 *CsrUtf8StrNCpyZero(u8 *target, const u8 *source, size_t count)
{
CsrStrNCpy((char *) target, (const char *) source, count);
if (target[count - 1] != '\0')

24
drivers/staging/csr/csr_util.c
Просмотреть файл

@ -222,31 +222,31 @@ void CsrUInt32ToHex(u32 number, char *str)
/* String */
/*------------------------------------------------------------------*/
#ifndef CSR_USE_STDC_LIB
void *CsrMemCpy(void *dest, const void *src, CsrSize count)
void *CsrMemCpy(void *dest, const void *src, size_t count)
{
return memcpy(dest, src, count);
}
EXPORT_SYMBOL_GPL(CsrMemCpy);
void *CsrMemSet(void *dest, u8 c, CsrSize count)
void *CsrMemSet(void *dest, u8 c, size_t count)
{
return memset(dest, c, count);
}
EXPORT_SYMBOL_GPL(CsrMemSet);
void *CsrMemMove(void *dest, const void *src, CsrSize count)
void *CsrMemMove(void *dest, const void *src, size_t count)
{
return memmove(dest, src, count);
}
EXPORT_SYMBOL_GPL(CsrMemMove);
s32 CsrMemCmp(const void *buf1, const void *buf2, CsrSize count)
s32 CsrMemCmp(const void *buf1, const void *buf2, size_t count)
{
return memcmp(buf1, buf2, count);
}
EXPORT_SYMBOL_GPL(CsrMemCmp);
void *CsrMemDup(const void *buf1, CsrSize count)
void *CsrMemDup(const void *buf1, size_t count)
{
void *buf2 = NULL;
@ -266,7 +266,7 @@ char *CsrStrCpy(char *dest, const char *src)
return strcpy(dest, src);
}
char *CsrStrNCpy(char *dest, const char *src, CsrSize count)
char *CsrStrNCpy(char *dest, const char *src, size_t count)
{
return strncpy(dest, src, count);
}
@ -276,7 +276,7 @@ char *CsrStrCat(char *dest, const char *src)
return strcat(dest, src);
}
char *CsrStrNCat(char *dest, const char *src, CsrSize count)
char *CsrStrNCat(char *dest, const char *src, size_t count)
{
return strncat(dest, src, count);
}
@ -286,7 +286,7 @@ char *CsrStrStr(const char *string1, const char *string2)
return strstr(string1, string2);
}
CsrSize CsrStrLen(const char *string)
size_t CsrStrLen(const char *string)
{
return strlen(string);
}
@ -297,7 +297,7 @@ s32 CsrStrCmp(const char *string1, const char *string2)
return strcmp(string1, string2);
}
s32 CsrStrNCmp(const char *string1, const char *string2, CsrSize count)
s32 CsrStrNCmp(const char *string1, const char *string2, size_t count)
{
return strncmp(string1, string2, count);
}
@ -308,7 +308,7 @@ char *CsrStrChr(const char *string, char c)
}
#endif
s32 CsrVsnprintf(char *string, CsrSize count, const char *format, va_list args)
s32 CsrVsnprintf(char *string, size_t count, const char *format, va_list args)
{
return vsnprintf(string, count, format, args);
}
@ -316,7 +316,7 @@ EXPORT_SYMBOL_GPL(CsrVsnprintf);
char *CsrStrNCpyZero(char *dest,
const char *src,
CsrSize count)
size_t count)
{
CsrStrNCpy(dest, src, count - 1);
dest[count - 1] = '\0';
@ -364,7 +364,7 @@ char *CsrStrDup(const char *string)
int CsrStrNICmp(const char *string1,
const char *string2,
CsrSize count)
size_t count)
{
u32 index;
int returnValue = 0;

26
drivers/staging/csr/csr_util.h
Просмотреть файл

@ -52,30 +52,30 @@ void CsrUInt32ToHex(u32 number, char *str);
#define CsrMemSet memset
#define CsrStrLen strlen
#else /* !CSR_USE_STDC_LIB */
void *CsrMemCpy(void *dest, const void *src, CsrSize count);
void *CsrMemMove(void *dest, const void *src, CsrSize count);
void *CsrMemCpy(void *dest, const void *src, size_t count);
void *CsrMemMove(void *dest, const void *src, size_t count);
char *CsrStrCpy(char *dest, const char *src);
char *CsrStrNCpy(char *dest, const char *src, CsrSize count);
char *CsrStrNCpy(char *dest, const char *src, size_t 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);
char *CsrStrNCat(char *dest, const char *src, size_t count);
s32 CsrMemCmp(const void *buf1, const void *buf2, size_t count);
s32 CsrStrCmp(const char *string1, const char *string2);
s32 CsrStrNCmp(const char *string1, const char *string2, CsrSize count);
s32 CsrStrNCmp(const char *string1, const char *string2, size_t 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 char *string);
void *CsrMemSet(void *dest, u8 c, size_t count);
size_t CsrStrLen(const char *string);
#endif /* !CSR_USE_STDC_LIB */
s32 CsrVsnprintf(char *string, CsrSize count, const char *format, va_list args);
s32 CsrVsnprintf(char *string, size_t count, const char *format, va_list args);
/*------------------------------------------------------------------*/
/* Non-standard utility functions */
/*------------------------------------------------------------------*/
void *CsrMemDup(const void *buf1, CsrSize count);
int CsrStrNICmp(const char *string1, const char *string2, CsrSize count);
void *CsrMemDup(const void *buf1, size_t count);
int CsrStrNICmp(const char *string1, const char *string2, size_t count);
char *CsrStrDup(const char *string);
u32 CsrStrToInt(const char *string);
char *CsrStrNCpyZero(char *dest, const char *src, CsrSize count);
char *CsrStrNCpyZero(char *dest, const char *src, size_t count);
/*------------------------------------------------------------------*/
/* Filename */
@ -86,7 +86,7 @@ const char *CsrGetBaseName(const char *file);
/* Misc */
/*------------------------------------------------------------------*/
u8 CsrIsSpace(u8 c);
#define CsrOffsetOf(st, m) ((CsrSize) & ((st *) 0)->m)
#define CsrOffsetOf(st, m) ((size_t) & ((st *) 0)->m)
#ifdef __cplusplus
}

46
drivers/staging/csr/csr_wifi_msgconv.h
Просмотреть файл

@ -21,37 +21,37 @@ extern "C" {
#endif
void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, u16 v);
void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, u32 v);
void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, u32 v);
void CsrUint16SerBigEndian(u8 *ptr, size_t *len, u16 v);
void CsrUint24SerBigEndian(u8 *ptr, size_t *len, u32 v);
void CsrUint32SerBigEndian(u8 *ptr, size_t *len, u32 v);
void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset);
void CsrUint24DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset);
void CsrUint32DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset);
void CsrUint16DesBigEndian(u16 *v, u8 *buffer, size_t *offset);
void CsrUint24DesBigEndian(u32 *v, u8 *buffer, size_t *offset);
void CsrUint32DesBigEndian(u32 *v, u8 *buffer, size_t *offset);
void CsrUint24Ser(u8 *ptr, CsrSize *len, u32 v);
void CsrUint24Des(u32 *v, u8 *buffer, CsrSize *offset);
void CsrUint24Ser(u8 *ptr, size_t *len, u32 v);
void CsrUint24Des(u32 *v, u8 *buffer, size_t *offset);
CsrSize CsrWifiEventSizeof(void *msg);
u8* CsrWifiEventSer(u8 *ptr, CsrSize *len, void *msg);
void* CsrWifiEventDes(u8 *buffer, CsrSize length);
size_t CsrWifiEventSizeof(void *msg);
u8* CsrWifiEventSer(u8 *ptr, size_t *len, void *msg);
void* CsrWifiEventDes(u8 *buffer, size_t length);
CsrSize CsrWifiEventCsrUint8Sizeof(void *msg);
u8* CsrWifiEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
void* CsrWifiEventCsrUint8Des(u8 *buffer, CsrSize length);
size_t CsrWifiEventCsrUint8Sizeof(void *msg);
u8* CsrWifiEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg);
void* CsrWifiEventCsrUint8Des(u8 *buffer, size_t length);
CsrSize CsrWifiEventCsrUint16Sizeof(void *msg);
u8* CsrWifiEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
void* CsrWifiEventCsrUint16Des(u8 *buffer, CsrSize length);
size_t CsrWifiEventCsrUint16Sizeof(void *msg);
u8* CsrWifiEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg);
void* CsrWifiEventCsrUint16Des(u8 *buffer, size_t length);
CsrSize CsrWifiEventCsrUint32Sizeof(void *msg);
u8* CsrWifiEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
void* CsrWifiEventCsrUint32Des(u8 *buffer, CsrSize length);
size_t CsrWifiEventCsrUint32Sizeof(void *msg);
u8* CsrWifiEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg);
void* CsrWifiEventCsrUint32Des(u8 *buffer, size_t length);
CsrSize CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg);
u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length);
size_t CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg);
u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg);
void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, size_t length);
#ifdef __cplusplus
}

100
drivers/staging/csr/csr_wifi_nme_ap_serialize.c
Просмотреть файл

@ -26,10 +26,10 @@ void CsrWifiNmeApPfree(void *ptr)
}
CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg)
size_t CsrWifiNmeApConfigSetReqSizeof(void *msg)
{
CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) msg;
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 104) */
bufferSize += 2; /* u16 primitive->apConfig.apGroupkeyTimeout */
@ -88,7 +88,7 @@ CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg)
}
u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *)msg;
*len = 0;
@ -149,10 +149,10 @@ u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, CsrSize length)
void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, size_t length)
{
CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApConfigSetReq));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -226,9 +226,9 @@ void CsrWifiNmeApConfigSetReqSerFree(void *voidPrimitivePointer)
}
CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg)
size_t CsrWifiNmeApWpsRegisterReqSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -239,7 +239,7 @@ CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg)
}
u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *)msg;
*len = 0;
@ -252,10 +252,10 @@ u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize length)
void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, size_t length)
{
CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterReq));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -268,10 +268,10 @@ void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
size_t CsrWifiNmeApStartReqSizeof(void *msg)
{
CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) msg;
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 112) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -355,7 +355,7 @@ CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
}
u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiNmeApStartReqSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *)msg;
*len = 0;
@ -444,10 +444,10 @@ u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize length)
void* CsrWifiNmeApStartReqDes(u8 *buffer, size_t length)
{
CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartReq));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -576,9 +576,9 @@ void CsrWifiNmeApStartReqSerFree(void *voidPrimitivePointer)
}
CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
size_t CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 51) */
{
@ -607,7 +607,7 @@ CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
}
u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *)msg;
*len = 0;
@ -638,10 +638,10 @@ u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize length)
void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, size_t length)
{
CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWmmParamUpdateReq));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -672,9 +672,9 @@ void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg)
size_t CsrWifiNmeApStaRemoveReqSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -684,7 +684,7 @@ CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg)
}
u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *)msg;
*len = 0;
@ -696,10 +696,10 @@ u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize length)
void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, size_t length)
{
CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStaRemoveReq));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -711,9 +711,9 @@ void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg)
size_t CsrWifiNmeApWpsRegisterCfmSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -722,7 +722,7 @@ CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg)
}
u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *)msg;
*len = 0;
@ -733,10 +733,10 @@ u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize length)
void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, size_t length)
{
CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterCfm));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -747,9 +747,9 @@ void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiNmeApStartCfmSizeof(void *msg)
size_t CsrWifiNmeApStartCfmSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 40) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -760,7 +760,7 @@ CsrSize CsrWifiNmeApStartCfmSizeof(void *msg)
}
u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiNmeApStartCfmSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *)msg;
*len = 0;
@ -773,10 +773,10 @@ u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize length)
void* CsrWifiNmeApStartCfmDes(u8 *buffer, size_t length)
{
CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartCfm));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -789,9 +789,9 @@ void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiNmeApStopCfmSizeof(void *msg)
size_t CsrWifiNmeApStopCfmSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -800,7 +800,7 @@ CsrSize CsrWifiNmeApStopCfmSizeof(void *msg)
}
u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiNmeApStopCfmSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *)msg;
*len = 0;
@ -811,10 +811,10 @@ u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize length)
void* CsrWifiNmeApStopCfmDes(u8 *buffer, size_t length)
{
CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopCfm));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -825,9 +825,9 @@ void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiNmeApStopIndSizeof(void *msg)
size_t CsrWifiNmeApStopIndSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -837,7 +837,7 @@ CsrSize CsrWifiNmeApStopIndSizeof(void *msg)
}
u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiNmeApStopIndSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *)msg;
*len = 0;
@ -849,10 +849,10 @@ u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize length)
void* CsrWifiNmeApStopIndDes(u8 *buffer, size_t length)
{
CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopInd));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -864,9 +864,9 @@ void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiNmeApStationIndSizeof(void *msg)
size_t CsrWifiNmeApStationIndSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -877,7 +877,7 @@ CsrSize CsrWifiNmeApStationIndSizeof(void *msg)
}
u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiNmeApStationIndSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *)msg;
*len = 0;
@ -890,10 +890,10 @@ u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiNmeApStationIndDes(u8 *buffer, CsrSize length)
void* CsrWifiNmeApStationIndDes(u8 *buffer, size_t length)
{
CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStationInd));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);

60
drivers/staging/csr/csr_wifi_nme_ap_serialize.h
Просмотреть файл

@ -32,19 +32,19 @@ extern "C" {
extern void CsrWifiNmeApPfree(void *ptr);
extern u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg);
extern u8* CsrWifiNmeApConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeApConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeApConfigSetReqSizeof(void *msg);
extern void CsrWifiNmeApConfigSetReqSerFree(void *msg);
extern u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg);
extern u8* CsrWifiNmeApWpsRegisterReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeApWpsRegisterReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeApWpsRegisterReqSizeof(void *msg);
#define CsrWifiNmeApWpsRegisterReqSerFree CsrWifiNmeApPfree
extern u8* CsrWifiNmeApStartReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeApStartReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStartReqSizeof(void *msg);
extern u8* CsrWifiNmeApStartReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeApStartReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeApStartReqSizeof(void *msg);
extern void CsrWifiNmeApStartReqSerFree(void *msg);
#define CsrWifiNmeApStopReqSer CsrWifiEventCsrUint16Ser
@ -52,14 +52,14 @@ extern void CsrWifiNmeApStartReqSerFree(void *msg);
#define CsrWifiNmeApStopReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiNmeApStopReqSerFree CsrWifiNmeApPfree
extern u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg);
extern u8* CsrWifiNmeApWmmParamUpdateReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeApWmmParamUpdateReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg);
#define CsrWifiNmeApWmmParamUpdateReqSerFree CsrWifiNmeApPfree
extern u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg);
extern u8* CsrWifiNmeApStaRemoveReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeApStaRemoveReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeApStaRemoveReqSizeof(void *msg);
#define CsrWifiNmeApStaRemoveReqSerFree CsrWifiNmeApPfree
#define CsrWifiNmeApConfigSetCfmSer CsrWifiEventCsrUint16Ser
@ -67,24 +67,24 @@ extern CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg);
#define CsrWifiNmeApConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiNmeApConfigSetCfmSerFree CsrWifiNmeApPfree
extern u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg);
extern u8* CsrWifiNmeApWpsRegisterCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeApWpsRegisterCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeApWpsRegisterCfmSizeof(void *msg);
#define CsrWifiNmeApWpsRegisterCfmSerFree CsrWifiNmeApPfree
extern u8* CsrWifiNmeApStartCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeApStartCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStartCfmSizeof(void *msg);
extern u8* CsrWifiNmeApStartCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeApStartCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeApStartCfmSizeof(void *msg);
#define CsrWifiNmeApStartCfmSerFree CsrWifiNmeApPfree
extern u8* CsrWifiNmeApStopCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeApStopCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStopCfmSizeof(void *msg);
extern u8* CsrWifiNmeApStopCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeApStopCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeApStopCfmSizeof(void *msg);
#define CsrWifiNmeApStopCfmSerFree CsrWifiNmeApPfree
extern u8* CsrWifiNmeApStopIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeApStopIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStopIndSizeof(void *msg);
extern u8* CsrWifiNmeApStopIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeApStopIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeApStopIndSizeof(void *msg);
#define CsrWifiNmeApStopIndSerFree CsrWifiNmeApPfree
#define CsrWifiNmeApWmmParamUpdateCfmSer CsrWifiEventCsrUint16Ser
@ -92,9 +92,9 @@ extern CsrSize CsrWifiNmeApStopIndSizeof(void *msg);
#define CsrWifiNmeApWmmParamUpdateCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiNmeApWmmParamUpdateCfmSerFree CsrWifiNmeApPfree
extern u8* CsrWifiNmeApStationIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeApStationIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeApStationIndSizeof(void *msg);
extern u8* CsrWifiNmeApStationIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeApStationIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeApStationIndSizeof(void *msg);
#define CsrWifiNmeApStationIndSerFree CsrWifiNmeApPfree

108
drivers/staging/csr/csr_wifi_nme_serialize.h
Просмотреть файл

@ -29,14 +29,14 @@ extern "C" {
extern void CsrWifiNmePfree(void *ptr);
extern u8* CsrWifiNmeProfileSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeProfileSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileSetReqSizeof(void *msg);
extern u8* CsrWifiNmeProfileSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeProfileSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeProfileSetReqSizeof(void *msg);
extern void CsrWifiNmeProfileSetReqSerFree(void *msg);
extern u8* CsrWifiNmeProfileDeleteReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeProfileDeleteReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileDeleteReqSizeof(void *msg);
extern u8* CsrWifiNmeProfileDeleteReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeProfileDeleteReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeProfileDeleteReqSizeof(void *msg);
#define CsrWifiNmeProfileDeleteReqSerFree CsrWifiNmePfree
#define CsrWifiNmeProfileDeleteAllReqSer CsrWifiEventSer
@ -44,19 +44,19 @@ extern CsrSize CsrWifiNmeProfileDeleteReqSizeof(void *msg);
#define CsrWifiNmeProfileDeleteAllReqSizeof CsrWifiEventSizeof
#define CsrWifiNmeProfileDeleteAllReqSerFree CsrWifiNmePfree
extern u8* CsrWifiNmeProfileOrderSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeProfileOrderSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileOrderSetReqSizeof(void *msg);
extern u8* CsrWifiNmeProfileOrderSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeProfileOrderSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeProfileOrderSetReqSizeof(void *msg);
extern void CsrWifiNmeProfileOrderSetReqSerFree(void *msg);
extern u8* CsrWifiNmeProfileConnectReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeProfileConnectReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileConnectReqSizeof(void *msg);
extern u8* CsrWifiNmeProfileConnectReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeProfileConnectReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeProfileConnectReqSizeof(void *msg);
#define CsrWifiNmeProfileConnectReqSerFree CsrWifiNmePfree
extern u8* CsrWifiNmeWpsReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeWpsReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeWpsReqSizeof(void *msg);
extern u8* CsrWifiNmeWpsReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeWpsReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeWpsReqSizeof(void *msg);
#define CsrWifiNmeWpsReqSerFree CsrWifiNmePfree
#define CsrWifiNmeWpsCancelReqSer CsrWifiEventCsrUint16Ser
@ -69,24 +69,24 @@ extern CsrSize CsrWifiNmeWpsReqSizeof(void *msg);
#define CsrWifiNmeConnectionStatusGetReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiNmeConnectionStatusGetReqSerFree CsrWifiNmePfree
extern u8* CsrWifiNmeSimImsiGetResSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeSimImsiGetResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeSimImsiGetResSizeof(void *msg);
extern u8* CsrWifiNmeSimImsiGetResSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeSimImsiGetResDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeSimImsiGetResSizeof(void *msg);
extern void CsrWifiNmeSimImsiGetResSerFree(void *msg);
extern u8* CsrWifiNmeSimGsmAuthResSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeSimGsmAuthResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeSimGsmAuthResSizeof(void *msg);
extern u8* CsrWifiNmeSimGsmAuthResSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeSimGsmAuthResDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeSimGsmAuthResSizeof(void *msg);
extern void CsrWifiNmeSimGsmAuthResSerFree(void *msg);
extern u8* CsrWifiNmeSimUmtsAuthResSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeSimUmtsAuthResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeSimUmtsAuthResSizeof(void *msg);
extern u8* CsrWifiNmeSimUmtsAuthResSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeSimUmtsAuthResDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeSimUmtsAuthResSizeof(void *msg);
extern void CsrWifiNmeSimUmtsAuthResSerFree(void *msg);
extern u8* CsrWifiNmeWpsConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeWpsConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeWpsConfigSetReqSizeof(void *msg);
extern u8* CsrWifiNmeWpsConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeWpsConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeWpsConfigSetReqSizeof(void *msg);
extern void CsrWifiNmeWpsConfigSetReqSerFree(void *msg);
#define CsrWifiNmeEventMaskSetReqSer CsrWifiEventCsrUint32Ser
@ -109,39 +109,39 @@ extern void CsrWifiNmeWpsConfigSetReqSerFree(void *msg);
#define CsrWifiNmeProfileDeleteAllCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiNmeProfileDeleteAllCfmSerFree CsrWifiNmePfree
extern u8* CsrWifiNmeProfileOrderSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeProfileOrderSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileOrderSetCfmSizeof(void *msg);
extern u8* CsrWifiNmeProfileOrderSetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeProfileOrderSetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeProfileOrderSetCfmSizeof(void *msg);
#define CsrWifiNmeProfileOrderSetCfmSerFree CsrWifiNmePfree
extern u8* CsrWifiNmeProfileConnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeProfileConnectCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileConnectCfmSizeof(void *msg);
extern u8* CsrWifiNmeProfileConnectCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeProfileConnectCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeProfileConnectCfmSizeof(void *msg);
extern void CsrWifiNmeProfileConnectCfmSerFree(void *msg);
extern u8* CsrWifiNmeWpsCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeWpsCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeWpsCfmSizeof(void *msg);
extern u8* CsrWifiNmeWpsCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeWpsCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeWpsCfmSizeof(void *msg);
extern void CsrWifiNmeWpsCfmSerFree(void *msg);
extern u8* CsrWifiNmeWpsCancelCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeWpsCancelCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeWpsCancelCfmSizeof(void *msg);
extern u8* CsrWifiNmeWpsCancelCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeWpsCancelCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeWpsCancelCfmSizeof(void *msg);
#define CsrWifiNmeWpsCancelCfmSerFree CsrWifiNmePfree
extern u8* CsrWifiNmeConnectionStatusGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeConnectionStatusGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeConnectionStatusGetCfmSizeof(void *msg);
extern u8* CsrWifiNmeConnectionStatusGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeConnectionStatusGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeConnectionStatusGetCfmSizeof(void *msg);
#define CsrWifiNmeConnectionStatusGetCfmSerFree CsrWifiNmePfree
extern u8* CsrWifiNmeProfileUpdateIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeProfileUpdateIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileUpdateIndSizeof(void *msg);
extern u8* CsrWifiNmeProfileUpdateIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeProfileUpdateIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeProfileUpdateIndSizeof(void *msg);
extern void CsrWifiNmeProfileUpdateIndSerFree(void *msg);
extern u8* CsrWifiNmeProfileDisconnectIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeProfileDisconnectIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeProfileDisconnectIndSizeof(void *msg);
extern u8* CsrWifiNmeProfileDisconnectIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeProfileDisconnectIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeProfileDisconnectIndSizeof(void *msg);
extern void CsrWifiNmeProfileDisconnectIndSerFree(void *msg);
#define CsrWifiNmeSimImsiGetIndSer CsrWifiEventSer
@ -149,14 +149,14 @@ extern void CsrWifiNmeProfileDisconnectIndSerFree(void *msg);
#define CsrWifiNmeSimImsiGetIndSizeof CsrWifiEventSizeof
#define CsrWifiNmeSimImsiGetIndSerFree CsrWifiNmePfree
extern u8* CsrWifiNmeSimGsmAuthIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeSimGsmAuthIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeSimGsmAuthIndSizeof(void *msg);
extern u8* CsrWifiNmeSimGsmAuthIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeSimGsmAuthIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeSimGsmAuthIndSizeof(void *msg);
extern void CsrWifiNmeSimGsmAuthIndSerFree(void *msg);
extern u8* CsrWifiNmeSimUmtsAuthIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiNmeSimUmtsAuthIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiNmeSimUmtsAuthIndSizeof(void *msg);
extern u8* CsrWifiNmeSimUmtsAuthIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiNmeSimUmtsAuthIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiNmeSimUmtsAuthIndSizeof(void *msg);
#define CsrWifiNmeSimUmtsAuthIndSerFree CsrWifiNmePfree
#define CsrWifiNmeWpsConfigSetCfmSer CsrWifiEventCsrUint16Ser

510
drivers/staging/csr/csr_wifi_router_ctrl_serialize.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

306
drivers/staging/csr/csr_wifi_router_ctrl_serialize.h
Просмотреть файл

@ -25,49 +25,49 @@ extern "C" {
extern void CsrWifiRouterCtrlPfree(void *ptr);
extern u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlConfigurePowerModeReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlConfigurePowerModeReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg);
#define CsrWifiRouterCtrlConfigurePowerModeReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlHipReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlHipReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlHipReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlHipReqSizeof(void *msg);
extern void CsrWifiRouterCtrlHipReqSerFree(void *msg);
extern u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlMediaStatusReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlMediaStatusReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg);
#define CsrWifiRouterCtrlMediaStatusReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg);
extern u8* CsrWifiRouterCtrlMulticastAddressResSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlMulticastAddressResDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg);
extern void CsrWifiRouterCtrlMulticastAddressResSerFree(void *msg);
extern u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlPortConfigureReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlPortConfigureReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg);
#define CsrWifiRouterCtrlPortConfigureReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlQosControlReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlQosControlReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlQosControlReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlQosControlReqSizeof(void *msg);
#define CsrWifiRouterCtrlQosControlReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlSuspendResSizeof(void *msg);
extern u8* CsrWifiRouterCtrlSuspendResSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlSuspendResDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlSuspendResSizeof(void *msg);
#define CsrWifiRouterCtrlSuspendResSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTclasAddReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlTclasAddReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlTclasAddReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlTclasAddReqSizeof(void *msg);
extern void CsrWifiRouterCtrlTclasAddReqSerFree(void *msg);
extern u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg);
extern u8* CsrWifiRouterCtrlResumeResSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlResumeResDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlResumeResSizeof(void *msg);
#define CsrWifiRouterCtrlResumeResSerFree CsrWifiRouterCtrlPfree
#define CsrWifiRouterCtrlRawSdioDeinitialiseReqSer CsrWifiEventCsrUint16Ser
@ -80,19 +80,19 @@ extern CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg);
#define CsrWifiRouterCtrlRawSdioInitialiseReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiRouterCtrlRawSdioInitialiseReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTclasDelReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlTclasDelReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlTclasDelReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlTclasDelReqSizeof(void *msg);
extern void CsrWifiRouterCtrlTclasDelReqSerFree(void *msg);
extern u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlTrafficClassificationReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlTrafficClassificationReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg);
#define CsrWifiRouterCtrlTrafficClassificationReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlTrafficConfigReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlTrafficConfigReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg);
#define CsrWifiRouterCtrlTrafficConfigReqSerFree CsrWifiRouterCtrlPfree
#define CsrWifiRouterCtrlWifiOffReqSer CsrWifiEventCsrUint16Ser
@ -105,39 +105,39 @@ extern CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg);
#define CsrWifiRouterCtrlWifiOffResSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiRouterCtrlWifiOffResSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWifiOnReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlWifiOnReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlWifiOnReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlWifiOnReqSizeof(void *msg);
extern void CsrWifiRouterCtrlWifiOnReqSerFree(void *msg);
extern u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg);
extern u8* CsrWifiRouterCtrlWifiOnResSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlWifiOnResDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlWifiOnResSizeof(void *msg);
extern void CsrWifiRouterCtrlWifiOnResSerFree(void *msg);
extern u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlM4TransmitReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlM4TransmitReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg);
#define CsrWifiRouterCtrlM4TransmitReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlModeSetReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlModeSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlModeSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlModeSetReqSizeof(void *msg);
#define CsrWifiRouterCtrlModeSetReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerAddReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlPeerAddReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlPeerAddReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlPeerAddReqSizeof(void *msg);
#define CsrWifiRouterCtrlPeerAddReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerDelReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlPeerDelReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlPeerDelReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlPeerDelReqSizeof(void *msg);
#define CsrWifiRouterCtrlPeerDelReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlPeerUpdateReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlPeerUpdateReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg);
#define CsrWifiRouterCtrlPeerUpdateReqSerFree CsrWifiRouterCtrlPfree
#define CsrWifiRouterCtrlCapabilitiesReqSer CsrWifiEventCsrUint16Ser
@ -145,19 +145,19 @@ extern CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg);
#define CsrWifiRouterCtrlCapabilitiesReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiRouterCtrlCapabilitiesReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlBlockAckEnableReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlBlockAckEnableReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg);
#define CsrWifiRouterCtrlBlockAckEnableReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlBlockAckDisableReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlBlockAckDisableReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg);
#define CsrWifiRouterCtrlBlockAckDisableReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlWapiRxPktReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlWapiRxPktReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg);
extern void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *msg);
#define CsrWifiRouterCtrlWapiMulticastFilterReqSer CsrWifiEventCsrUint16CsrUint8Ser
@ -170,9 +170,9 @@ extern void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *msg);
#define CsrWifiRouterCtrlWapiUnicastFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
#define CsrWifiRouterCtrlWapiUnicastFilterReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg);
extern u8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg);
extern void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *msg);
#define CsrWifiRouterCtrlWapiFilterReqSer CsrWifiEventCsrUint16CsrUint8Ser
@ -180,19 +180,19 @@ extern void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *msg);
#define CsrWifiRouterCtrlWapiFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
#define CsrWifiRouterCtrlWapiFilterReqSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlHipIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlHipIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlHipIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlHipIndSizeof(void *msg);
extern void CsrWifiRouterCtrlHipIndSerFree(void *msg);
extern u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlMulticastAddressIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlMulticastAddressIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg);
extern void CsrWifiRouterCtrlMulticastAddressIndSerFree(void *msg);
extern u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlPortConfigureCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlPortConfigureCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg);
#define CsrWifiRouterCtrlPortConfigureCfmSerFree CsrWifiRouterCtrlPfree
#define CsrWifiRouterCtrlResumeIndSer CsrWifiEventCsrUint16CsrUint8Ser
@ -200,39 +200,39 @@ extern CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg);
#define CsrWifiRouterCtrlResumeIndSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
#define CsrWifiRouterCtrlResumeIndSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlSuspendIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlSuspendIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlSuspendIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlSuspendIndSizeof(void *msg);
#define CsrWifiRouterCtrlSuspendIndSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlTclasAddCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlTclasAddCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg);
#define CsrWifiRouterCtrlTclasAddCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg);
#define CsrWifiRouterCtrlRawSdioDeinitialiseCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg);
#define CsrWifiRouterCtrlRawSdioInitialiseCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlTclasDelCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlTclasDelCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg);
#define CsrWifiRouterCtrlTclasDelCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlTrafficProtocolIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlTrafficProtocolIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg);
#define CsrWifiRouterCtrlTrafficProtocolIndSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlTrafficSampleIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlTrafficSampleIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg);
#define CsrWifiRouterCtrlTrafficSampleIndSerFree CsrWifiRouterCtrlPfree
#define CsrWifiRouterCtrlWifiOffIndSer CsrWifiEventCsrUint16CsrUint8Ser
@ -245,94 +245,94 @@ extern CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg);
#define CsrWifiRouterCtrlWifiOffCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiRouterCtrlWifiOffCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWifiOnIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlWifiOnIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlWifiOnIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlWifiOnIndSizeof(void *msg);
extern void CsrWifiRouterCtrlWifiOnIndSerFree(void *msg);
extern u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlWifiOnCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlWifiOnCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg);
#define CsrWifiRouterCtrlWifiOnCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlM4ReadyToSendIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlM4ReadyToSendIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg);
#define CsrWifiRouterCtrlM4ReadyToSendIndSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlM4TransmittedIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlM4TransmittedIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg);
#define CsrWifiRouterCtrlM4TransmittedIndSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlMicFailureIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlMicFailureIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlMicFailureIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlMicFailureIndSizeof(void *msg);
#define CsrWifiRouterCtrlMicFailureIndSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlConnectedIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlConnectedIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlConnectedIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlConnectedIndSizeof(void *msg);
#define CsrWifiRouterCtrlConnectedIndSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlPeerAddCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlPeerAddCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg);
#define CsrWifiRouterCtrlPeerAddCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlPeerDelCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlPeerDelCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg);
#define CsrWifiRouterCtrlPeerDelCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlUnexpectedFrameIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlUnexpectedFrameIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg);
#define CsrWifiRouterCtrlUnexpectedFrameIndSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlPeerUpdateCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlPeerUpdateCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg);
#define CsrWifiRouterCtrlPeerUpdateCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlCapabilitiesCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlCapabilitiesCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg);
#define CsrWifiRouterCtrlCapabilitiesCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlBlockAckEnableCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlBlockAckEnableCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg);
#define CsrWifiRouterCtrlBlockAckEnableCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlBlockAckDisableCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlBlockAckDisableCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg);
#define CsrWifiRouterCtrlBlockAckDisableCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlBlockAckErrorIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlBlockAckErrorIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg);
#define CsrWifiRouterCtrlBlockAckErrorIndSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlStaInactiveIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlStaInactiveIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg);
#define CsrWifiRouterCtrlStaInactiveIndSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg);
extern void CsrWifiRouterCtrlWapiRxMicCheckIndSerFree(void *msg);
extern u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlModeSetCfmSizeof(void *msg);
extern u8* CsrWifiRouterCtrlModeSetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlModeSetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlModeSetCfmSizeof(void *msg);
#define CsrWifiRouterCtrlModeSetCfmSerFree CsrWifiRouterCtrlPfree
extern u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg);
extern u8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg);
extern void CsrWifiRouterCtrlWapiUnicastTxEncryptIndSerFree(void *msg);

80
drivers/staging/csr/csr_wifi_router_serialize.c
Просмотреть файл

@ -24,9 +24,9 @@ void CsrWifiRouterPfree(void *ptr)
}
CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg)
size_t CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -37,7 +37,7 @@ CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg)
}
u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *)msg;
*len = 0;
@ -50,10 +50,10 @@ u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize length)
void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, size_t length)
{
CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeReq));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -66,10 +66,10 @@ void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg)
size_t CsrWifiRouterMaPacketReqSizeof(void *msg)
{
CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) msg;
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 20) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -84,7 +84,7 @@ CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg)
}
u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *)msg;
*len = 0;
@ -104,10 +104,10 @@ u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiRouterMaPacketReqDes(u8 *buffer, CsrSize length)
void* CsrWifiRouterMaPacketReqDes(u8 *buffer, size_t length)
{
CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketReq));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -141,9 +141,9 @@ void CsrWifiRouterMaPacketReqSerFree(void *voidPrimitivePointer)
}
CsrSize CsrWifiRouterMaPacketResSizeof(void *msg)
size_t CsrWifiRouterMaPacketResSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -153,7 +153,7 @@ CsrSize CsrWifiRouterMaPacketResSizeof(void *msg)
}
u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiRouterMaPacketResSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *)msg;
*len = 0;
@ -165,10 +165,10 @@ u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize length)
void* CsrWifiRouterMaPacketResDes(u8 *buffer, size_t length)
{
CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketRes));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -180,9 +180,9 @@ void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg)
size_t CsrWifiRouterMaPacketCancelReqSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -193,7 +193,7 @@ CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg)
}
u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *)msg;
*len = 0;
@ -206,10 +206,10 @@ u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize length)
void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, size_t length)
{
CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCancelReq));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -222,9 +222,9 @@ void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg)
size_t CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -235,7 +235,7 @@ CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg)
}
u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *)msg;
*len = 0;
@ -248,10 +248,10 @@ u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize length)
void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, size_t length)
{
CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeCfm));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -264,9 +264,9 @@ void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg)
size_t CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -275,7 +275,7 @@ CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg)
}
u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *)msg;
*len = 0;
@ -286,10 +286,10 @@ u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize length)
void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, size_t length)
{
CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketUnsubscribeCfm));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -300,9 +300,9 @@ void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg)
size_t CsrWifiRouterMaPacketCfmSizeof(void *msg)
{
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -313,7 +313,7 @@ CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg)
}
u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *)msg;
*len = 0;
@ -326,10 +326,10 @@ u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize length)
void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, size_t length)
{
CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCfm));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
@ -342,10 +342,10 @@ void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize length)
}
CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg)
size_t CsrWifiRouterMaPacketIndSizeof(void *msg)
{
CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) msg;
CsrSize bufferSize = 2;
size_t bufferSize = 2;
/* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
bufferSize += 2; /* u16 primitive->interfaceTag */
@ -361,7 +361,7 @@ CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg)
}
u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *)msg;
*len = 0;
@ -382,10 +382,10 @@ u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg)
}
void* CsrWifiRouterMaPacketIndDes(u8 *buffer, CsrSize length)
void* CsrWifiRouterMaPacketIndDes(u8 *buffer, size_t length)
{
CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketInd));
CsrSize offset;
size_t offset;
offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);

48
drivers/staging/csr/csr_wifi_router_serialize.h
Просмотреть файл

@ -25,9 +25,9 @@ extern "C" {
extern void CsrWifiRouterPfree(void *ptr);
extern u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg);
extern u8* CsrWifiRouterMaPacketSubscribeReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterMaPacketSubscribeReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg);
#define CsrWifiRouterMaPacketSubscribeReqSerFree CsrWifiRouterPfree
#define CsrWifiRouterMaPacketUnsubscribeReqSer CsrWifiEventCsrUint16CsrUint8Ser
@ -35,39 +35,39 @@ extern CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg);
#define CsrWifiRouterMaPacketUnsubscribeReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
#define CsrWifiRouterMaPacketUnsubscribeReqSerFree CsrWifiRouterPfree
extern u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterMaPacketReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg);
extern u8* CsrWifiRouterMaPacketReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterMaPacketReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterMaPacketReqSizeof(void *msg);
extern void CsrWifiRouterMaPacketReqSerFree(void *msg);
extern u8* CsrWifiRouterMaPacketResSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterMaPacketResDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketResSizeof(void *msg);
extern u8* CsrWifiRouterMaPacketResSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterMaPacketResDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterMaPacketResSizeof(void *msg);
#define CsrWifiRouterMaPacketResSerFree CsrWifiRouterPfree
extern u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg);
extern u8* CsrWifiRouterMaPacketCancelReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterMaPacketCancelReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterMaPacketCancelReqSizeof(void *msg);
#define CsrWifiRouterMaPacketCancelReqSerFree CsrWifiRouterPfree
extern u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg);
extern u8* CsrWifiRouterMaPacketSubscribeCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterMaPacketSubscribeCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg);
#define CsrWifiRouterMaPacketSubscribeCfmSerFree CsrWifiRouterPfree
extern u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg);
extern u8* CsrWifiRouterMaPacketUnsubscribeCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterMaPacketUnsubscribeCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg);
#define CsrWifiRouterMaPacketUnsubscribeCfmSerFree CsrWifiRouterPfree
extern u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg);
extern u8* CsrWifiRouterMaPacketCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterMaPacketCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterMaPacketCfmSizeof(void *msg);
#define CsrWifiRouterMaPacketCfmSerFree CsrWifiRouterPfree
extern u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiRouterMaPacketIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg);
extern u8* CsrWifiRouterMaPacketIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiRouterMaPacketIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiRouterMaPacketIndSizeof(void *msg);
extern void CsrWifiRouterMaPacketIndSerFree(void *msg);

10
drivers/staging/csr/csr_wifi_router_transport.c
Просмотреть файл

@ -61,14 +61,14 @@ void CsrWifiRouterTransportDeinit(unifi_priv_t *priv)
}
}
void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLength)
void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, size_t bufferLength)
{
CsrMsgConvMsgEntry* msgEntry;
u16 primType;
CsrSchedQid src;
CsrSchedQid dest;
u16 msgType;
CsrSize offset = 0;
size_t offset = 0;
CsrWifiFsmEvent* msg;
/* Decode the prim and message type */
@ -163,9 +163,9 @@ static void CsrWifiRouterTransportSerialiseAndSend(u16 primType, void* msg)
{
CsrWifiFsmEvent* evt = (CsrWifiFsmEvent*)msg;
CsrMsgConvMsgEntry* msgEntry;
CsrSize msgSize;
CsrSize encodeBufferLen = 0;
CsrSize offset = 0;
size_t msgSize;
size_t encodeBufferLen = 0;
size_t offset = 0;
u8* encodeBuffer;
unifi_trace(drvpriv, UDBG4, "CsrWifiRouterTransportSerialiseAndSend: primType=0x%.4X, msgType=0x%.4X\n",

56
drivers/staging/csr/csr_wifi_serialize_primitive_types.c
Просмотреть файл

@ -16,7 +16,7 @@
#include "csr_wifi_msgconv.h"
#include "csr_wifi_lib.h"
void CsrUint24Des(u32 *v, u8 *buffer, CsrSize *offset)
void CsrUint24Des(u32 *v, u8 *buffer, size_t *offset)
{
u32 val;
@ -30,7 +30,7 @@ void CsrUint24Des(u32 *v, u8 *buffer, CsrSize *offset)
/* Big endian :e.g WSC, TCLAS */
void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset)
void CsrUint16DesBigEndian(u16 *v, u8 *buffer, size_t *offset)
{
u16 val;
@ -41,7 +41,7 @@ void CsrUint16DesBigEndian(u16 *v, u8 *buffer, CsrSize *offset)
}
void CsrUint24DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset)
void CsrUint24DesBigEndian(u32 *v, u8 *buffer, size_t *offset)
{
u32 val;
@ -54,7 +54,7 @@ void CsrUint24DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset)
}
void CsrUint32DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset)
void CsrUint32DesBigEndian(u32 *v, u8 *buffer, size_t *offset)
{
u32 val;
@ -68,7 +68,7 @@ void CsrUint32DesBigEndian(u32 *v, u8 *buffer, CsrSize *offset)
}
void CsrUint24Ser(u8 *ptr, CsrSize *len, u32 v)
void CsrUint24Ser(u8 *ptr, size_t *len, u32 v)
{
ptr[(*len) + 2] = (u8)((v & 0x00ff0000) >> 16);
ptr[(*len) + 1] = (u8)((v & 0x0000ff00) >> 8);
@ -79,7 +79,7 @@ void CsrUint24Ser(u8 *ptr, CsrSize *len, u32 v)
/* Big endian :e.g WSC, TCLAS */
void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, u16 v)
void CsrUint16SerBigEndian(u8 *ptr, size_t *len, u16 v)
{
ptr[(*len)] = (u8)((v & 0xff00) >> 8);
ptr[(*len) + 1] = (u8)((v & 0x00ff));
@ -88,7 +88,7 @@ void CsrUint16SerBigEndian(u8 *ptr, CsrSize *len, u16 v)
}
void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, u32 v)
void CsrUint32SerBigEndian(u8 *ptr, size_t *len, u32 v)
{
ptr[(*len)] = (u8)((v & 0xff000000) >> 24);
ptr[(*len) + 1] = (u8)((v & 0x00ff0000) >> 16);
@ -99,7 +99,7 @@ void CsrUint32SerBigEndian(u8 *ptr, CsrSize *len, u32 v)
}
void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, u32 v)
void CsrUint24SerBigEndian(u8 *ptr, size_t *len, u32 v)
{
ptr[(*len)] = (u8)((v & 0x00ff0000) >> 16);
ptr[(*len) + 1] = (u8)((v & 0x0000ff00) >> 8);
@ -109,13 +109,13 @@ void CsrUint24SerBigEndian(u8 *ptr, CsrSize *len, u32 v)
}
CsrSize CsrWifiEventSizeof(void *msg)
size_t CsrWifiEventSizeof(void *msg)
{
return 2;
}
EXPORT_SYMBOL_GPL(CsrWifiEventSizeof);
u8* CsrWifiEventSer(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiEventSer(u8 *ptr, size_t *len, void *msg)
{
CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *)msg;
*len = 0;
@ -124,23 +124,23 @@ u8* CsrWifiEventSer(u8 *ptr, CsrSize *len, void *msg)
}
EXPORT_SYMBOL_GPL(CsrWifiEventSer);
void* CsrWifiEventDes(u8 *buffer, CsrSize length)
void* CsrWifiEventDes(u8 *buffer, size_t length)
{
CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *) CsrPmemAlloc(sizeof(CsrWifiFsmEvent));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->type, buffer, &offset);
return primitive;
}
EXPORT_SYMBOL_GPL(CsrWifiEventDes);
CsrSize CsrWifiEventCsrUint8Sizeof(void *msg)
size_t CsrWifiEventCsrUint8Sizeof(void *msg)
{
return 3;
}
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Sizeof);
u8* CsrWifiEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg)
{
CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *)msg;
*len = 0;
@ -151,11 +151,11 @@ u8* CsrWifiEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Ser);
void* CsrWifiEventCsrUint8Des(u8 *buffer, CsrSize length)
void* CsrWifiEventCsrUint8Des(u8 *buffer, size_t length)
{
CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint8));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint8Des(&primitive->value, buffer, &offset);
@ -164,14 +164,14 @@ void* CsrWifiEventCsrUint8Des(u8 *buffer, CsrSize length)
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Des);
CsrSize CsrWifiEventCsrUint16Sizeof(void *msg)
size_t CsrWifiEventCsrUint16Sizeof(void *msg)
{
return 4;
}
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Sizeof);
u8* CsrWifiEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg)
{
CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *)msg;
*len = 0;
@ -181,11 +181,11 @@ u8* CsrWifiEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg)
}
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Ser);
void* CsrWifiEventCsrUint16Des(u8 *buffer, CsrSize length)
void* CsrWifiEventCsrUint16Des(u8 *buffer, size_t length)
{
CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des(&primitive->value, buffer, &offset);
@ -194,13 +194,13 @@ void* CsrWifiEventCsrUint16Des(u8 *buffer, CsrSize length)
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Des);
CsrSize CsrWifiEventCsrUint32Sizeof(void *msg)
size_t CsrWifiEventCsrUint32Sizeof(void *msg)
{
return 6;
}
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Sizeof);
u8* CsrWifiEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg)
{
CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *)msg;
*len = 0;
@ -211,11 +211,11 @@ u8* CsrWifiEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg)
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Ser);
void* CsrWifiEventCsrUint32Des(u8 *buffer, CsrSize length)
void* CsrWifiEventCsrUint32Des(u8 *buffer, size_t length)
{
CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint32));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint32Des(&primitive->value, buffer, &offset);
@ -223,13 +223,13 @@ void* CsrWifiEventCsrUint32Des(u8 *buffer, CsrSize length)
}
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Des);
CsrSize CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg)
size_t CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg)
{
return 5;
}
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Sizeof);
u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg)
{
CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *)msg;
*len = 0;
@ -241,11 +241,11 @@ u8* CsrWifiEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg)
EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Ser);
void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length)
void* CsrWifiEventCsrUint16CsrUint8Des(u8 *buffer, size_t length)
{
CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16CsrUint8));
CsrSize offset = 0;
size_t offset = 0;
CsrUint16Des(&primitive->common.type, buffer, &offset);
CsrUint16Des(&primitive->value16, buffer, &offset);
CsrUint8Des(&primitive->value8, buffer, &offset);

790
drivers/staging/csr/csr_wifi_sme_serialize.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

474
drivers/staging/csr/csr_wifi_sme_serialize.h
Просмотреть файл

@ -35,14 +35,14 @@ extern void CsrWifiSmePfree(void *ptr);
#define CsrWifiSmeAdhocConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeAdhocConfigGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeAdhocConfigSetReqSizeof(void *msg);
extern u8* CsrWifiSmeAdhocConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeAdhocConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeAdhocConfigSetReqSizeof(void *msg);
#define CsrWifiSmeAdhocConfigSetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeBlacklistReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeBlacklistReqSizeof(void *msg);
extern u8* CsrWifiSmeBlacklistReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeBlacklistReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeBlacklistReqSizeof(void *msg);
extern void CsrWifiSmeBlacklistReqSerFree(void *msg);
#define CsrWifiSmeCalibrationDataGetReqSer CsrWifiEventSer
@ -50,9 +50,9 @@ extern void CsrWifiSmeBlacklistReqSerFree(void *msg);
#define CsrWifiSmeCalibrationDataGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeCalibrationDataGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCalibrationDataSetReqSizeof(void *msg);
extern u8* CsrWifiSmeCalibrationDataSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCalibrationDataSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCalibrationDataSetReqSizeof(void *msg);
extern void CsrWifiSmeCalibrationDataSetReqSerFree(void *msg);
#define CsrWifiSmeCcxConfigGetReqSer CsrWifiEventCsrUint16Ser
@ -60,9 +60,9 @@ extern void CsrWifiSmeCalibrationDataSetReqSerFree(void *msg);
#define CsrWifiSmeCcxConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeCcxConfigGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg);
extern u8* CsrWifiSmeCcxConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCcxConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCcxConfigSetReqSizeof(void *msg);
#define CsrWifiSmeCcxConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeCoexConfigGetReqSer CsrWifiEventSer
@ -70,9 +70,9 @@ extern CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg);
#define CsrWifiSmeCoexConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeCoexConfigGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg);
extern u8* CsrWifiSmeCoexConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCoexConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCoexConfigSetReqSizeof(void *msg);
#define CsrWifiSmeCoexConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeCoexInfoGetReqSer CsrWifiEventSer
@ -80,9 +80,9 @@ extern CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg);
#define CsrWifiSmeCoexInfoGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeCoexInfoGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeConnectReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeConnectReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectReqSizeof(void *msg);
extern u8* CsrWifiSmeConnectReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeConnectReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeConnectReqSizeof(void *msg);
extern void CsrWifiSmeConnectReqSerFree(void *msg);
#define CsrWifiSmeConnectionConfigGetReqSer CsrWifiEventCsrUint16Ser
@ -120,14 +120,14 @@ extern void CsrWifiSmeConnectReqSerFree(void *msg);
#define CsrWifiSmeHostConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeHostConfigGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeHostConfigSetReqSizeof(void *msg);
extern u8* CsrWifiSmeHostConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeHostConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeHostConfigSetReqSizeof(void *msg);
#define CsrWifiSmeHostConfigSetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeKeyReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeKeyReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeKeyReqSizeof(void *msg);
extern u8* CsrWifiSmeKeyReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeKeyReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeKeyReqSizeof(void *msg);
#define CsrWifiSmeKeyReqSerFree CsrWifiSmePfree
#define CsrWifiSmeLinkQualityGetReqSer CsrWifiEventCsrUint16Ser
@ -140,34 +140,34 @@ extern CsrSize CsrWifiSmeKeyReqSizeof(void *msg);
#define CsrWifiSmeMibConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeMibConfigGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibConfigSetReqSizeof(void *msg);
extern u8* CsrWifiSmeMibConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMibConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMibConfigSetReqSizeof(void *msg);
#define CsrWifiSmeMibConfigSetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibGetNextReqSizeof(void *msg);
extern u8* CsrWifiSmeMibGetNextReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMibGetNextReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMibGetNextReqSizeof(void *msg);
extern void CsrWifiSmeMibGetNextReqSerFree(void *msg);
extern u8* CsrWifiSmeMibGetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMibGetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibGetReqSizeof(void *msg);
extern u8* CsrWifiSmeMibGetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMibGetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMibGetReqSizeof(void *msg);
extern void CsrWifiSmeMibGetReqSerFree(void *msg);
extern u8* CsrWifiSmeMibSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMibSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibSetReqSizeof(void *msg);
extern u8* CsrWifiSmeMibSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMibSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMibSetReqSizeof(void *msg);
extern void CsrWifiSmeMibSetReqSerFree(void *msg);
extern u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMulticastAddressReqSizeof(void *msg);
extern u8* CsrWifiSmeMulticastAddressReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMulticastAddressReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMulticastAddressReqSizeof(void *msg);
extern void CsrWifiSmeMulticastAddressReqSerFree(void *msg);
extern u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePacketFilterSetReqSizeof(void *msg);
extern u8* CsrWifiSmePacketFilterSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmePacketFilterSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmePacketFilterSetReqSizeof(void *msg);
extern void CsrWifiSmePacketFilterSetReqSerFree(void *msg);
#define CsrWifiSmePermanentMacAddressGetReqSer CsrWifiEventSer
@ -175,9 +175,9 @@ extern void CsrWifiSmePacketFilterSetReqSerFree(void *msg);
#define CsrWifiSmePermanentMacAddressGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmePermanentMacAddressGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmePmkidReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmePmkidReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePmkidReqSizeof(void *msg);
extern u8* CsrWifiSmePmkidReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmePmkidReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmePmkidReqSizeof(void *msg);
extern void CsrWifiSmePmkidReqSerFree(void *msg);
#define CsrWifiSmePowerConfigGetReqSer CsrWifiEventSer
@ -185,9 +185,9 @@ extern void CsrWifiSmePmkidReqSerFree(void *msg);
#define CsrWifiSmePowerConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmePowerConfigGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg);
extern u8* CsrWifiSmePowerConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmePowerConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmePowerConfigSetReqSizeof(void *msg);
#define CsrWifiSmePowerConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeRegulatoryDomainInfoGetReqSer CsrWifiEventSer
@ -200,9 +200,9 @@ extern CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg);
#define CsrWifiSmeRoamingConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeRoamingConfigGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg);
extern u8* CsrWifiSmeRoamingConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeRoamingConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeRoamingConfigSetReqSizeof(void *msg);
#define CsrWifiSmeRoamingConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeScanConfigGetReqSer CsrWifiEventSer
@ -210,14 +210,14 @@ extern CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg);
#define CsrWifiSmeScanConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeScanConfigGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeScanConfigSetReqSizeof(void *msg);
extern u8* CsrWifiSmeScanConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeScanConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeScanConfigSetReqSizeof(void *msg);
extern void CsrWifiSmeScanConfigSetReqSerFree(void *msg);
extern u8* CsrWifiSmeScanFullReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeScanFullReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeScanFullReqSizeof(void *msg);
extern u8* CsrWifiSmeScanFullReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeScanFullReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeScanFullReqSizeof(void *msg);
extern void CsrWifiSmeScanFullReqSerFree(void *msg);
#define CsrWifiSmeScanResultsFlushReqSer CsrWifiEventSer
@ -235,9 +235,9 @@ extern void CsrWifiSmeScanFullReqSerFree(void *msg);
#define CsrWifiSmeSmeStaConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeSmeStaConfigGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg);
extern u8* CsrWifiSmeSmeStaConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeSmeStaConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg);
#define CsrWifiSmeSmeStaConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeStationMacAddressGetReqSer CsrWifiEventSer
@ -245,9 +245,9 @@ extern CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg);
#define CsrWifiSmeStationMacAddressGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeStationMacAddressGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeTspecReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeTspecReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeTspecReqSizeof(void *msg);
extern u8* CsrWifiSmeTspecReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeTspecReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeTspecReqSizeof(void *msg);
extern void CsrWifiSmeTspecReqSerFree(void *msg);
#define CsrWifiSmeVersionsGetReqSer CsrWifiEventSer
@ -255,9 +255,9 @@ extern void CsrWifiSmeTspecReqSerFree(void *msg);
#define CsrWifiSmeVersionsGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeVersionsGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeWifiFlightmodeReqSizeof(void *msg);
extern u8* CsrWifiSmeWifiFlightmodeReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeWifiFlightmodeReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeWifiFlightmodeReqSizeof(void *msg);
extern void CsrWifiSmeWifiFlightmodeReqSerFree(void *msg);
#define CsrWifiSmeWifiOffReqSer CsrWifiEventSer
@ -265,14 +265,14 @@ extern void CsrWifiSmeWifiFlightmodeReqSerFree(void *msg);
#define CsrWifiSmeWifiOffReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeWifiOffReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeWifiOnReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeWifiOnReqSizeof(void *msg);
extern u8* CsrWifiSmeWifiOnReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeWifiOnReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeWifiOnReqSizeof(void *msg);
extern void CsrWifiSmeWifiOnReqSerFree(void *msg);
extern u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg);
extern u8* CsrWifiSmeCloakedSsidsSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCloakedSsidsSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg);
extern void CsrWifiSmeCloakedSsidsSetReqSerFree(void *msg);
#define CsrWifiSmeCloakedSsidsGetReqSer CsrWifiEventSer
@ -285,9 +285,9 @@ extern void CsrWifiSmeCloakedSsidsSetReqSerFree(void *msg);
#define CsrWifiSmeSmeCommonConfigGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeSmeCommonConfigGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg);
extern u8* CsrWifiSmeSmeCommonConfigSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeSmeCommonConfigSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg);
#define CsrWifiSmeSmeCommonConfigSetReqSerFree CsrWifiSmePfree
#define CsrWifiSmeInterfaceCapabilityGetReqSer CsrWifiEventSer
@ -295,14 +295,14 @@ extern CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg);
#define CsrWifiSmeInterfaceCapabilityGetReqSizeof CsrWifiEventSizeof
#define CsrWifiSmeInterfaceCapabilityGetReqSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeWpsConfigurationReqSizeof(void *msg);
extern u8* CsrWifiSmeWpsConfigurationReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeWpsConfigurationReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeWpsConfigurationReqSizeof(void *msg);
extern void CsrWifiSmeWpsConfigurationReqSerFree(void *msg);
extern u8* CsrWifiSmeSetReqSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeSetReqDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSetReqSizeof(void *msg);
extern u8* CsrWifiSmeSetReqSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeSetReqDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeSetReqSizeof(void *msg);
extern void CsrWifiSmeSetReqSerFree(void *msg);
#define CsrWifiSmeActivateCfmSer CsrWifiEventCsrUint16Ser
@ -310,9 +310,9 @@ extern void CsrWifiSmeSetReqSerFree(void *msg);
#define CsrWifiSmeActivateCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeActivateCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeAdhocConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeAdhocConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeAdhocConfigGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeAdhocConfigSetCfmSer CsrWifiEventCsrUint16Ser
@ -320,24 +320,24 @@ extern CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeAdhocConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeAdhocConfigSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg);
extern u8* CsrWifiSmeAssociationCompleteIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeAssociationCompleteIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeAssociationCompleteIndSizeof(void *msg);
extern void CsrWifiSmeAssociationCompleteIndSerFree(void *msg);
extern u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeAssociationStartIndSizeof(void *msg);
extern u8* CsrWifiSmeAssociationStartIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeAssociationStartIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeAssociationStartIndSizeof(void *msg);
#define CsrWifiSmeAssociationStartIndSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeBlacklistCfmSizeof(void *msg);
extern u8* CsrWifiSmeBlacklistCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeBlacklistCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeBlacklistCfmSizeof(void *msg);
extern void CsrWifiSmeBlacklistCfmSerFree(void *msg);
extern u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeCalibrationDataGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCalibrationDataGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg);
extern void CsrWifiSmeCalibrationDataGetCfmSerFree(void *msg);
#define CsrWifiSmeCalibrationDataSetCfmSer CsrWifiEventCsrUint16Ser
@ -345,19 +345,19 @@ extern void CsrWifiSmeCalibrationDataGetCfmSerFree(void *msg);
#define CsrWifiSmeCalibrationDataSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeCalibrationDataSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCcxConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeCcxConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCcxConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCcxConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeCcxConfigGetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCcxConfigSetCfmSizeof(void *msg);
extern u8* CsrWifiSmeCcxConfigSetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCcxConfigSetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCcxConfigSetCfmSizeof(void *msg);
#define CsrWifiSmeCcxConfigSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeCoexConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCoexConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCoexConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeCoexConfigGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeCoexConfigSetCfmSer CsrWifiEventCsrUint16Ser
@ -365,34 +365,34 @@ extern CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeCoexConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeCoexConfigSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCoexInfoGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeCoexInfoGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCoexInfoGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCoexInfoGetCfmSizeof(void *msg);
#define CsrWifiSmeCoexInfoGetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeConnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeConnectCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectCfmSizeof(void *msg);
extern u8* CsrWifiSmeConnectCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeConnectCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeConnectCfmSizeof(void *msg);
#define CsrWifiSmeConnectCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeConnectionConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeConnectionConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg);
extern void CsrWifiSmeConnectionConfigGetCfmSerFree(void *msg);
extern u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeConnectionInfoGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeConnectionInfoGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg);
extern void CsrWifiSmeConnectionInfoGetCfmSerFree(void *msg);
extern u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectionQualityIndSizeof(void *msg);
extern u8* CsrWifiSmeConnectionQualityIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeConnectionQualityIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeConnectionQualityIndSizeof(void *msg);
#define CsrWifiSmeConnectionQualityIndSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeConnectionStatsGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeConnectionStatsGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg);
#define CsrWifiSmeConnectionStatsGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeDeactivateCfmSer CsrWifiEventCsrUint16Ser
@ -400,9 +400,9 @@ extern CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg);
#define CsrWifiSmeDeactivateCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeDeactivateCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg);
extern u8* CsrWifiSmeDisconnectCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeDisconnectCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeDisconnectCfmSizeof(void *msg);
#define CsrWifiSmeDisconnectCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeEventMaskSetCfmSer CsrWifiEventCsrUint16Ser
@ -410,39 +410,39 @@ extern CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg);
#define CsrWifiSmeEventMaskSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeEventMaskSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeHostConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeHostConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeHostConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeHostConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeHostConfigGetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeHostConfigSetCfmSizeof(void *msg);
extern u8* CsrWifiSmeHostConfigSetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeHostConfigSetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeHostConfigSetCfmSizeof(void *msg);
#define CsrWifiSmeHostConfigSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeIbssStationIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeIbssStationIndSizeof(void *msg);
extern u8* CsrWifiSmeIbssStationIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeIbssStationIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeIbssStationIndSizeof(void *msg);
#define CsrWifiSmeIbssStationIndSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeKeyCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeKeyCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeKeyCfmSizeof(void *msg);
extern u8* CsrWifiSmeKeyCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeKeyCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeKeyCfmSizeof(void *msg);
#define CsrWifiSmeKeyCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeLinkQualityGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeLinkQualityGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeLinkQualityGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeLinkQualityGetCfmSizeof(void *msg);
#define CsrWifiSmeLinkQualityGetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg);
extern u8* CsrWifiSmeMediaStatusIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMediaStatusIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMediaStatusIndSizeof(void *msg);
extern void CsrWifiSmeMediaStatusIndSerFree(void *msg);
extern u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeMibConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMibConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMibConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeMibConfigGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeMibConfigSetCfmSer CsrWifiEventCsrUint16Ser
@ -450,14 +450,14 @@ extern CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeMibConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeMibConfigSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMibGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeMibGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMibGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMibGetCfmSizeof(void *msg);
extern void CsrWifiSmeMibGetCfmSerFree(void *msg);
extern u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMibGetNextCfmSizeof(void *msg);
extern u8* CsrWifiSmeMibGetNextCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMibGetNextCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMibGetNextCfmSizeof(void *msg);
extern void CsrWifiSmeMibGetNextCfmSerFree(void *msg);
#define CsrWifiSmeMibSetCfmSer CsrWifiEventCsrUint16Ser
@ -465,39 +465,39 @@ extern void CsrWifiSmeMibGetNextCfmSerFree(void *msg);
#define CsrWifiSmeMibSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeMibSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMicFailureIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMicFailureIndSizeof(void *msg);
extern u8* CsrWifiSmeMicFailureIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMicFailureIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMicFailureIndSizeof(void *msg);
#define CsrWifiSmeMicFailureIndSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeMulticastAddressCfmSizeof(void *msg);
extern u8* CsrWifiSmeMulticastAddressCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeMulticastAddressCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeMulticastAddressCfmSizeof(void *msg);
extern void CsrWifiSmeMulticastAddressCfmSerFree(void *msg);
extern u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePacketFilterSetCfmSizeof(void *msg);
extern u8* CsrWifiSmePacketFilterSetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmePacketFilterSetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmePacketFilterSetCfmSizeof(void *msg);
#define CsrWifiSmePacketFilterSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg);
extern u8* CsrWifiSmePermanentMacAddressGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmePermanentMacAddressGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg);
#define CsrWifiSmePermanentMacAddressGetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg);
extern u8* CsrWifiSmePmkidCandidateListIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmePmkidCandidateListIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmePmkidCandidateListIndSizeof(void *msg);
extern void CsrWifiSmePmkidCandidateListIndSerFree(void *msg);
extern u8* CsrWifiSmePmkidCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmePmkidCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePmkidCfmSizeof(void *msg);
extern u8* CsrWifiSmePmkidCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmePmkidCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmePmkidCfmSizeof(void *msg);
extern void CsrWifiSmePmkidCfmSerFree(void *msg);
extern u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmePowerConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmePowerConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmePowerConfigGetCfmSizeof(void *msg);
#define CsrWifiSmePowerConfigGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmePowerConfigSetCfmSer CsrWifiEventCsrUint16Ser
@ -505,34 +505,34 @@ extern CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg);
#define CsrWifiSmePowerConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmePowerConfigSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg);
#define CsrWifiSmeRegulatoryDomainInfoGetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRoamCompleteIndSizeof(void *msg);
extern u8* CsrWifiSmeRoamCompleteIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeRoamCompleteIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeRoamCompleteIndSizeof(void *msg);
#define CsrWifiSmeRoamCompleteIndSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeRoamStartIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRoamStartIndSizeof(void *msg);
extern u8* CsrWifiSmeRoamStartIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeRoamStartIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeRoamStartIndSizeof(void *msg);
#define CsrWifiSmeRoamStartIndSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeRoamingConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeRoamingConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeRoamingConfigGetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg);
extern u8* CsrWifiSmeRoamingConfigSetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeRoamingConfigSetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg);
#define CsrWifiSmeRoamingConfigSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeScanConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeScanConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeScanConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeScanConfigGetCfmSizeof(void *msg);
extern void CsrWifiSmeScanConfigGetCfmSerFree(void *msg);
#define CsrWifiSmeScanConfigSetCfmSer CsrWifiEventCsrUint16Ser
@ -545,9 +545,9 @@ extern void CsrWifiSmeScanConfigGetCfmSerFree(void *msg);
#define CsrWifiSmeScanFullCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeScanFullCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeScanResultIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeScanResultIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeScanResultIndSizeof(void *msg);
extern u8* CsrWifiSmeScanResultIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeScanResultIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeScanResultIndSizeof(void *msg);
extern void CsrWifiSmeScanResultIndSerFree(void *msg);
#define CsrWifiSmeScanResultsFlushCfmSer CsrWifiEventCsrUint16Ser
@ -555,39 +555,39 @@ extern void CsrWifiSmeScanResultIndSerFree(void *msg);
#define CsrWifiSmeScanResultsFlushCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeScanResultsFlushCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeScanResultsGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeScanResultsGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeScanResultsGetCfmSizeof(void *msg);
extern void CsrWifiSmeScanResultsGetCfmSerFree(void *msg);
extern u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeSmeStaConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeSmeStaConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeSmeStaConfigGetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg);
extern u8* CsrWifiSmeSmeStaConfigSetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeSmeStaConfigSetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg);
#define CsrWifiSmeSmeStaConfigSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeStationMacAddressGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeStationMacAddressGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg);
#define CsrWifiSmeStationMacAddressGetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeTspecIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeTspecIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeTspecIndSizeof(void *msg);
extern u8* CsrWifiSmeTspecIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeTspecIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeTspecIndSizeof(void *msg);
extern void CsrWifiSmeTspecIndSerFree(void *msg);
extern u8* CsrWifiSmeTspecCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeTspecCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeTspecCfmSizeof(void *msg);
extern u8* CsrWifiSmeTspecCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeTspecCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeTspecCfmSizeof(void *msg);
extern void CsrWifiSmeTspecCfmSerFree(void *msg);
extern u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeVersionsGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeVersionsGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeVersionsGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeVersionsGetCfmSizeof(void *msg);
extern void CsrWifiSmeVersionsGetCfmSerFree(void *msg);
#define CsrWifiSmeWifiFlightmodeCfmSer CsrWifiEventCsrUint16Ser
@ -615,19 +615,19 @@ extern void CsrWifiSmeVersionsGetCfmSerFree(void *msg);
#define CsrWifiSmeCloakedSsidsSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeCloakedSsidsSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeCloakedSsidsGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCloakedSsidsGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg);
extern void CsrWifiSmeCloakedSsidsGetCfmSerFree(void *msg);
extern u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeWifiOnIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeWifiOnIndSizeof(void *msg);
extern u8* CsrWifiSmeWifiOnIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeWifiOnIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeWifiOnIndSizeof(void *msg);
#define CsrWifiSmeWifiOnIndSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeSmeCommonConfigGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeSmeCommonConfigGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeSmeCommonConfigGetCfmSerFree CsrWifiSmePfree
#define CsrWifiSmeSmeCommonConfigSetCfmSer CsrWifiEventCsrUint16Ser
@ -635,24 +635,24 @@ extern CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg);
#define CsrWifiSmeSmeCommonConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
#define CsrWifiSmeSmeCommonConfigSetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg);
extern u8* CsrWifiSmeInterfaceCapabilityGetCfmSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeInterfaceCapabilityGetCfmDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg);
#define CsrWifiSmeInterfaceCapabilityGetCfmSerFree CsrWifiSmePfree
extern u8* CsrWifiSmeErrorIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeErrorIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeErrorIndSizeof(void *msg);
extern u8* CsrWifiSmeErrorIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeErrorIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeErrorIndSizeof(void *msg);
extern void CsrWifiSmeErrorIndSerFree(void *msg);
extern u8* CsrWifiSmeInfoIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeInfoIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeInfoIndSizeof(void *msg);
extern u8* CsrWifiSmeInfoIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeInfoIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeInfoIndSizeof(void *msg);
extern void CsrWifiSmeInfoIndSerFree(void *msg);
extern u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, CsrSize *len, void *msg);
extern void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, CsrSize len);
extern CsrSize CsrWifiSmeCoreDumpIndSizeof(void *msg);
extern u8* CsrWifiSmeCoreDumpIndSer(u8 *ptr, size_t *len, void *msg);
extern void* CsrWifiSmeCoreDumpIndDes(u8 *buffer, size_t len);
extern size_t CsrWifiSmeCoreDumpIndSizeof(void *msg);
extern void CsrWifiSmeCoreDumpIndSerFree(void *msg);
#define CsrWifiSmeAmpStatusChangeIndSer CsrWifiEventCsrUint16CsrUint8Ser

2
drivers/staging/csr/sme_userspace.h
Просмотреть файл

@ -32,7 +32,7 @@ int uf_sme_queue_message(unifi_priv_t *priv, u8 *buffer, int length);
#include "csr_wifi_sme_lib.h"
void CsrWifiRouterTransportInit(unifi_priv_t *priv);
void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, CsrSize bufferLength);
void CsrWifiRouterTransportRecv(unifi_priv_t *priv, u8* buffer, size_t bufferLength);
void CsrWifiRouterTransportDeInit(unifi_priv_t *priv);
#endif /* __LINUX_SME_USERSPACE_H__ */