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>

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;

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
 }

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

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
 
 

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

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

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 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);
-
-CsrSize CsrEventSizeof(void *msg);
-u8 *CsrEventSer(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventDes(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint8Sizeof(void *msg);
-u8 *CsrEventCsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint8Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint16Sizeof(void *msg);
-u8 *CsrEventCsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint32Sizeof(void *msg);
-u8 *CsrEventCsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint16CsrUint8Sizeof(void *msg);
-u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint16CsrUint16Sizeof(void *msg);
-u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint16CsrUint32Sizeof(void *msg);
-u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint16CsrCharStringSizeof(void *msg);
-u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint32CsrUint16Sizeof(void *msg);
-u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, CsrSize length);
-
-CsrSize CsrEventCsrUint32CsrCharStringSizeof(void *msg);
-u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, CsrSize *len, void *msg);
-void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, CsrSize length);
+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, 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);
+
+size_t CsrEventSizeof(void *msg);
+u8 *CsrEventSer(u8 *ptr, size_t *len, void *msg);
+void *CsrEventDes(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint8Sizeof(void *msg);
+u8 *CsrEventCsrUint8Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint8Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint16Sizeof(void *msg);
+u8 *CsrEventCsrUint16Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint16Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint32Sizeof(void *msg);
+u8 *CsrEventCsrUint32Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint32Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint16CsrUint8Sizeof(void *msg);
+u8 *CsrEventCsrUint16CsrUint8Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint16CsrUint8Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint16CsrUint16Sizeof(void *msg);
+u8 *CsrEventCsrUint16CsrUint16Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint16CsrUint16Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint16CsrUint32Sizeof(void *msg);
+u8 *CsrEventCsrUint16CsrUint32Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint16CsrUint32Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint16CsrCharStringSizeof(void *msg);
+u8 *CsrEventCsrUint16CsrCharStringSer(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint16CsrCharStringDes(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint32CsrUint16Sizeof(void *msg);
+u8 *CsrEventCsrUint32CsrUint16Ser(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint32CsrUint16Des(u8 *buffer, size_t length);
+
+size_t CsrEventCsrUint32CsrCharStringSizeof(void *msg);
+u8 *CsrEventCsrUint32CsrCharStringSer(u8 *ptr, size_t *len, void *msg);
+void *CsrEventCsrUint32CsrCharStringDes(u8 *buffer, size_t length);
 
 #ifdef __cplusplus
 }

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;
 

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