Skip to content

L
linux
Commit 957417bf authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files
Options

staging: csr: remove a bunch of unused functions in csr_util.c 

They were wrappers for other functions already in the kernel, and no one
was even calling them, so remove them.

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: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent c97dbc89
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 352 deletions
drivers/staging/csr/csr_util.c
View file @ 957417bf
...@@ -15,180 +15,10 @@ ...@@ -15,180 +15,10 @@
#include "csr_pmem.h" #include "csr_pmem.h"
#include "csr_util.h" #include "csr_util.h"
/*------------------------------------------------------------------*/
/* Bits */
/*------------------------------------------------------------------*/
/* Time proportional with the number of 1's */
u8 CsrBitCountSparse(u32 n)
{
u8 count = 0;
while (n)
{
count++;
n &= (n - 1);
}
return count;
}
/* Time proportional with the number of 0's */
u8 CsrBitCountDense(u32 n)
{
u8 count = 8 * sizeof(u32);
n ^= (u32) (-1);
while (n)
{
count--;
n &= (n - 1);
}
return count;
}
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
/* Base conversion */ /* Base conversion */
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
u8 CsrHexStrToUint8(const char *string, u8 *returnValue)
{
u16 currentIndex = 0;
*returnValue = 0;
if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
{
string += 2;
}
if (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
{
while (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
{
*returnValue = (u8) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
currentIndex++;
if (currentIndex >= 2)
{
break;
}
}
return TRUE;
}
return FALSE;
}
u8 CsrHexStrToUint16(const char *string, u16 *returnValue)
{
u16 currentIndex = 0;
*returnValue = 0;
if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
{
string += 2;
}
if (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
{
while (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
{
*returnValue = (u16) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
currentIndex++;
if (currentIndex >= 4)
{
break;
}
}
return TRUE;
}
return FALSE;
}
u8 CsrHexStrToUint32(const char *string, u32 *returnValue)
{
u16 currentIndex = 0;
*returnValue = 0;
if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
{
string += 2;
}
if (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
{
while (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
{
*returnValue = *returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10);
currentIndex++;
if (currentIndex >= 8)
{
break;
}
}
return TRUE;
}
return FALSE;
}
u32 CsrPow(u32 base, u32 exponent)
{
if (exponent == 0)
{
return 1;
}
else
{
u32 i, t = base;
for (i = 1; i < exponent; i++)
{
t = t * base;
}
return t;
}
}
/* Convert signed 32 bit (or less) integer to string */ /* Convert signed 32 bit (or less) integer to string */
#define I2B10_MAX 12
void CsrIntToBase10(s32 number, char *str)
{
s32 digit;
u8 index;
char res[I2B10_MAX];
u8 foundDigit = FALSE;
for (digit = 0; digit < I2B10_MAX; digit++)
{
res[digit] = '\0';
}
/* Catch sign - and deal with positive numbers only afterwards */
index = 0;
if (number < 0)
{
res[index++] = '-';
number = -1 * number;
}
digit = 1000000000;
if (number > 0)
{
while ((index < I2B10_MAX - 1) && (digit > 0))
{
/* If the foundDigit flag is TRUE, this routine should be proceeded.
Otherwise the number which has '0' digit cannot be converted correctly */
if (((number / digit) > 0) || foundDigit)
{
foundDigit = TRUE; /* set foundDigit flag to TRUE*/
res[index++] = (char) ('0' + (number / digit));
number = number % digit;
}
digit = digit / 10;
}
}
else
{
res[index] = (char) '0';
}
CsrStrCpy(str, res);
}
void CsrUInt16ToHex(u16 number, char *str) void CsrUInt16ToHex(u16 number, char *str)
{ {
u16 index; u16 index;
...@@ -203,20 +33,6 @@ void CsrUInt16ToHex(u16 number, char *str) ...@@ -203,20 +33,6 @@ void CsrUInt16ToHex(u16 number, char *str)
str[4] = '\0'; str[4] = '\0';
} }
void CsrUInt32ToHex(u32 number, char *str)
{
u16 index;
u32 currentValue;
for (index = 0; index < 8; index++)
{
currentValue = (u32) (number & 0x0000000F);
number >>= 4;
str[7 - index] = (char) (currentValue > 9 ? currentValue + 55 : currentValue + '0');
}
str[8] = '\0';
}
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
/* String */ /* String */
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
...@@ -244,19 +60,6 @@ s32 CsrMemCmp(const void *buf1, const void *buf2, size_t count) ...@@ -244,19 +60,6 @@ s32 CsrMemCmp(const void *buf1, const void *buf2, size_t count)
return memcmp(buf1, buf2, count); return memcmp(buf1, buf2, count);
} }
EXPORT_SYMBOL_GPL(CsrMemCmp); EXPORT_SYMBOL_GPL(CsrMemCmp);
void *CsrMemDup(const void *buf1, size_t count)
{
void *buf2 = NULL;
if (buf1)
{
buf2 = CsrPmemAlloc(count);
CsrMemCpy(buf2, buf1, count);
}
return buf2;
}
#endif #endif
#ifndef CSR_USE_STDC_LIB #ifndef CSR_USE_STDC_LIB
...@@ -270,21 +73,6 @@ char *CsrStrNCpy(char *dest, const char *src, size_t count) ...@@ -270,21 +73,6 @@ char *CsrStrNCpy(char *dest, const char *src, size_t count)
return strncpy(dest, src, count); return strncpy(dest, src, count);
} }
char *CsrStrCat(char *dest, const char *src)
{
return strcat(dest, src);
}
char *CsrStrNCat(char *dest, const char *src, size_t count)
{
return strncat(dest, src, count);
}
char *CsrStrStr(const char *string1, const char *string2)
{
return strstr(string1, string2);
}
size_t CsrStrLen(const char *string) size_t CsrStrLen(const char *string)
{ {
return strlen(string); return strlen(string);
...@@ -313,39 +101,6 @@ s32 CsrVsnprintf(char *string, size_t count, const char *format, va_list args) ...@@ -313,39 +101,6 @@ s32 CsrVsnprintf(char *string, size_t count, const char *format, va_list args)
} }
EXPORT_SYMBOL_GPL(CsrVsnprintf); EXPORT_SYMBOL_GPL(CsrVsnprintf);
char *CsrStrNCpyZero(char *dest,
const char *src,
size_t count)
{
CsrStrNCpy(dest, src, count - 1);
dest[count - 1] = '\0';
return dest;
}
/* Convert string with base 10 to integer */
u32 CsrStrToInt(const char *str)
{
s16 i;
u32 res;
u32 digit;
res = 0;
digit = 1;
/* Start from the string end */
for (i = (u16) (CsrStrLen(str) - 1); i >= 0; i--)
{
/* Only convert numbers */
if ((str[i] >= '0') && (str[i] <= '9'))
{
res += digit * (str[i] - '0');
digit = digit * 10;
}
}
return res;
}
char *CsrStrDup(const char *string) char *CsrStrDup(const char *string)
{ {
char *copy; char *copy;
...@@ -361,82 +116,6 @@ char *CsrStrDup(const char *string) ...@@ -361,82 +116,6 @@ char *CsrStrDup(const char *string)
return copy; return copy;
} }
int CsrStrNICmp(const char *string1,
const char *string2,
size_t count)
{
u32 index;
int returnValue = 0;
for (index = 0; index < count; index++)
{
if (CSR_TOUPPER(string1[index]) != CSR_TOUPPER(string2[index]))
{
if (CSR_TOUPPER(string1[index]) > CSR_TOUPPER(string2[index]))
{
returnValue = 1;
}
else
{
returnValue = -1;
}
break;
}
if (string1[index] == '\0')
{
break;
}
}
return returnValue;
}
const char *CsrGetBaseName(const char *file)
{
const char *pch;
static const char dotDir[] = ".";
if (!file)
{
return NULL;
}
if (file[0] == '\0')
{
return dotDir;
}
pch = file + CsrStrLen(file) - 1;
while (*pch != '\\' && *pch != '/' && *pch != ':')
{
if (pch == file)
{
return pch;
}
--pch;
}
return ++pch;
}
/*------------------------------------------------------------------*/
/* Misc */
/*------------------------------------------------------------------*/
u8 CsrIsSpace(u8 c)
{
switch (c)
{
case '\t':
case '\n':
case '\f':
case '\r':
case ' ':
return TRUE;
default:
return FALSE;
}
}
MODULE_DESCRIPTION("CSR Operating System Kernel Abstraction"); MODULE_DESCRIPTION("CSR Operating System Kernel Abstraction");
MODULE_AUTHOR("Cambridge Silicon Radio Ltd."); MODULE_AUTHOR("Cambridge Silicon Radio Ltd.");
MODULE_LICENSE("GPL and additional rights"); MODULE_LICENSE("GPL and additional rights");
drivers/staging/csr/csr_util.h
View file @ 957417bf
...@@ -18,22 +18,10 @@ extern "C" { ...@@ -18,22 +18,10 @@ extern "C" {
#include <linux/types.h> #include <linux/types.h>
#include "csr_macro.h" #include "csr_macro.h"
/*------------------------------------------------------------------*/
/* Bits - intended to operate on u32 values */
/*------------------------------------------------------------------*/
u8 CsrBitCountSparse(u32 n);
u8 CsrBitCountDense(u32 n);
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
/* Base conversion */ /* Base conversion */
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
u8 CsrHexStrToUint8(const char *string, u8 *returnValue);
u8 CsrHexStrToUint16(const char *string, u16 *returnValue);
u8 CsrHexStrToUint32(const char *string, u32 *returnValue);
u32 CsrPow(u32 base, u32 exponent);
void CsrIntToBase10(s32 number, char *str);
void CsrUInt16ToHex(u16 number, char *str); void CsrUInt16ToHex(u16 number, char *str);
void CsrUInt32ToHex(u32 number, char *str);
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
/* Standard C Library functions */ /* Standard C Library functions */
...@@ -43,13 +31,10 @@ void CsrUInt32ToHex(u32 number, char *str); ...@@ -43,13 +31,10 @@ void CsrUInt32ToHex(u32 number, char *str);
#define CsrMemMove memmove #define CsrMemMove memmove
#define CsrStrCpy strcpy #define CsrStrCpy strcpy
#define CsrStrNCpy strncpy #define CsrStrNCpy strncpy
#define CsrStrCat strcat
#define CsrStrNCat strncat
#define CsrMemCmp(s1, s2, n) ((s32) memcmp((s1), (s2), (n))) #define CsrMemCmp(s1, s2, n) ((s32) memcmp((s1), (s2), (n)))
#define CsrStrCmp(s1, s2) ((s32) strcmp((s1), (s2))) #define CsrStrCmp(s1, s2) ((s32) strcmp((s1), (s2)))
#define CsrStrNCmp(s1, s2, n) ((s32) strncmp((s1), (s2), (n))) #define CsrStrNCmp(s1, s2, n) ((s32) strncmp((s1), (s2), (n)))
#define CsrStrChr strchr #define CsrStrChr strchr
#define CsrStrStr strstr
#define CsrMemSet memset #define CsrMemSet memset
#define CsrStrLen strlen #define CsrStrLen strlen
#else /* !CSR_USE_STDC_LIB */ #else /* !CSR_USE_STDC_LIB */
...@@ -57,13 +42,10 @@ void *CsrMemCpy(void *dest, const void *src, size_t count); ...@@ -57,13 +42,10 @@ void *CsrMemCpy(void *dest, const void *src, size_t count);
void *CsrMemMove(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 *CsrStrCpy(char *dest, const char *src);
char *CsrStrNCpy(char *dest, const char *src, size_t 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, size_t count);
s32 CsrMemCmp(const void *buf1, const void *buf2, size_t count); s32 CsrMemCmp(const void *buf1, const void *buf2, size_t count);
s32 CsrStrCmp(const char *string1, const char *string2); s32 CsrStrCmp(const char *string1, const char *string2);
s32 CsrStrNCmp(const char *string1, const char *string2, size_t count); s32 CsrStrNCmp(const char *string1, const char *string2, size_t count);
char *CsrStrChr(const char *string, char c); char *CsrStrChr(const char *string, char c);
char *CsrStrStr(const char *string1, const char *string2);
void *CsrMemSet(void *dest, u8 c, size_t count); void *CsrMemSet(void *dest, u8 c, size_t count);
size_t CsrStrLen(const char *string); size_t CsrStrLen(const char *string);
#endif /* !CSR_USE_STDC_LIB */ #endif /* !CSR_USE_STDC_LIB */
...@@ -72,21 +54,8 @@ s32 CsrVsnprintf(char *string, size_t count, const char *format, va_list args); ...@@ -72,21 +54,8 @@ s32 CsrVsnprintf(char *string, size_t count, const char *format, va_list args);
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
/* Non-standard utility functions */ /* Non-standard utility functions */
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
void *CsrMemDup(const void *buf1, size_t count);
int CsrStrNICmp(const char *string1, const char *string2, size_t count);
char *CsrStrDup(const char *string); char *CsrStrDup(const char *string);
u32 CsrStrToInt(const char *string);
char *CsrStrNCpyZero(char *dest, const char *src, size_t count);
/*------------------------------------------------------------------*/
/* Filename */
/*------------------------------------------------------------------*/
const char *CsrGetBaseName(const char *file);
/*------------------------------------------------------------------*/
/* Misc */
/*------------------------------------------------------------------*/
u8 CsrIsSpace(u8 c);
#define CsrOffsetOf(st, m) ((size_t) & ((st *) 0)->m) #define CsrOffsetOf(st, m) ((size_t) & ((st *) 0)->m)
#ifdef __cplusplus #ifdef __cplusplus
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7